Providers¶

altimate supports 35+ LLM providers. Configure them in the provider section of your config file.

Provider Configuration¶

Each provider has a key in the provider object:

{
  "provider": {
    "<provider-name>": {
      "apiKey": "{env:API_KEY}",
      "baseURL": "https://custom.endpoint.com/v1",
      "headers": {
        "X-Custom-Header": "value"
      }
    }
  }
}

Tip

Use {env:...} substitution for API keys so you never commit secrets to version control.

Altimate LLM Gateway¶

Managed LLM access with dynamic routing across Sonnet 4.6, Opus 4.6, GPT-5.4, GPT-5.3, and more. No API keys to manage — 10M tokens free to get started.

{
  "provider": {
    "altimate": {}
  },
  "model": "altimate/auto"
}

For pricing, security, and data handling details, see the Altimate LLM Gateway guide.

Automatic model selection

When Altimate credentials are configured and no model is explicitly chosen, the Altimate LLM Gateway is selected automatically. You can override this by setting model in your config or by restricting the provider section to specific providers only.

Altimate Base¶

Altimate Base is Altimate's own hosted free model. It requires no signup or user-managed API key and is subject to rate limits and abuse protection.

Data handling: Requests and responses are logged and may be used to improve Altimate's products, including the model. Secrets are automatically masked before storage, but don't rely on it — avoid sending secrets or confidential code. Altimate Base is pseudonymous, not anonymous: a stable per-installation identifier links your requests across launches and altimate providers logout altimate-base does not reset it (see the security FAQ). Usage is rate limited.

If you need stronger guarantees — no training on your data, metadata-only retention — use the Altimate LLM Gateway instead.

Choose Altimate Base from the first-run picker or /connect — or do nothing at all: every install that is not yet registered registers it automatically at startup, so it works the same way headlessly (run, serve, acp, web). Startup waits up to three seconds for this; a slower registration finishes in the background and applies from the next launch (a serve client can apply it sooner through the register route). After a network error, rate limit or gateway server error, startup skips registration for a retry backoff of one hour (longer if the gateway asks, up to 24 hours). This happens whether or not you also have a model of your own; a registered Base only becomes your default when nothing you configured is usable. There is no confirmation dialog to accept. The disclosure above is shown once per install: in the TUI as a toast the first time Base becomes the active model, and for a headless entrypoint as a one-line notice to stderr the first time it runs with Base registered (serve skips it when ALTIMATE_CLI_CLIENT=datamates, since the VS Code extension shows its own notice). After registration, the model is available as altimate-free/altimate-base and becomes the free fallback when no paid Altimate Gateway or explicit model is selected. Big Pickle is retired as a new selection — it no longer appears in the picker or the full model catalog for users choosing a model for the first time. Users already on Big Pickle are migrated to Altimate Base the same automatic way once it registers, not through a separate confirmation: declinedManagedBaseDefault is still read from model.json for backward compatibility, but no longer changes the outcome — the keyless public Zen tier rejects unauthenticated traffic outright, so there is no longer a working "stay on public Zen" choice to honor.

To opt out: set ALTIMATE_BASE_AUTO_REGISTER=0 before this install first registers Base, run altimate providers logout altimate-base afterward, or keep it out of your own choices with enabled_providers / disabled_providers. The env var is the only one of these that stops the background registration call itself; the other two only control whether Base can be selected as your model on this machine. Logging out un-registers it and also stops automatic registration on this machine: later launches skip it until you pick Altimate Base again in the picker (or an IDE calls the registration route), which reconnects it.

Registration is per machine, not per host: once any host on a machine has registered Altimate Base (auto-registration on any entrypoint, or the HTTP registration route used by IDE integrations), every other host on that machine treats Base as the default free model too — the TUI migrates an implicit free default silently, and headless altimate run, altimate serve, and ACP sessions resolve to Base ahead of the keyless public Zen tier. Logging out on any host applies to all hosts on the machine, since the credential is a single shared file. Administrators auditing a fleet can check for the Altimate Base credential file, altimate-base.json, in the data directory (it is stored separately from the shared provider-auth file).

Official release binaries embed the current gateway endpoint at build time. Operators and local development can override it without changing code:

export ALTIMATE_BASE_GATEWAY_URL=https://your-gateway.example
altimate

The URL must use HTTPS. Credentials, query strings, and fragments in the URL are rejected. ALTIMATE_FREE_GATEWAY_URL is retained as a legacy fallback, but ALTIMATE_BASE_GATEWAY_URL takes precedence. If the configured gateway host changes, credentials issued by the previous host are not loaded and the registration flow must run again.

Altimate Base waits up to 5 minutes for the gateway to send response headers, because the backend can queue, cold-start, or reason before the first token arrives (a shorter wait would abort healthy requests with Provider response headers timed out). Override this in the field with ALTIMATE_BASE_HEADER_TIMEOUT_MS — a whole number of milliseconds, minimum 1000; values below the floor or non-numeric values are ignored and fall back to the default:

export ALTIMATE_BASE_HEADER_TIMEOUT_MS=600000  # wait up to 10 minutes for the first byte

This bounds only the wait for the first response byte; once the stream starts, a separate 5-minute watchdog guards against mid-stream stalls.

Altimate Base credentials are stored separately from the shared provider-auth file and are never returned to the TUI. The installation secret is hashed before registration; the gateway receives the hash, not the local secret.

That hash is stable across launches, so it links this installation's logged requests together — it is what enforces the free allowance. Running altimate providers logout altimate-base clears the credential but keeps the installation identity on purpose, so logging out is not a way to reset the allowance. Each inference request additionally carries a session identifier used for rate limiting. See the security FAQ for what this means for privacy and how to reset the local identity.

Anthropic¶

{
  "provider": {
    "anthropic": {
      "apiKey": "{env:ANTHROPIC_API_KEY}"
    }
  },
  "model": "anthropic/claude-sonnet-4-6"
}

Available models: claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5-20251001

OpenAI¶

{
  "provider": {
    "openai": {
      "apiKey": "{env:OPENAI_API_KEY}"
    }
  },
  "model": "openai/gpt-4o"
}

Amazon Bedrock¶

{
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1"
      }
    }
  },
  "model": "amazon-bedrock/anthropic.claude-sonnet-4-6-v1"
}

Uses the standard AWS credential chain: environment variables (AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY), named profiles (AWS_PROFILE), SSO sessions, IAM roles, and container credentials.

Note

If you have AWS SSO, IAM roles, or environment credentials (AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY) configured, Bedrock will use your default credential chain automatically.

Custom Endpoints (API Gateways)¶

If your organization routes Bedrock traffic through a custom API gateway or proxy, set the baseURL in the provider options:

{
  "provider": {
    "amazon-bedrock": {
      "options": {
        "baseURL": "https://your-gateway.example.com/v1",
        "region": "us-east-1"
      }
    }
  },
  "model": "amazon-bedrock/anthropic.claude-sonnet-4-6-v1"
}

For a complete walkthrough — including bearer token authentication, cross-region model IDs, and troubleshooting — see the Amazon Bedrock Custom Endpoints guide.

Azure OpenAI¶

{
  "provider": {
    "azure": {
      "apiKey": "{env:AZURE_OPENAI_API_KEY}",
      "baseURL": "https://your-resource.openai.azure.com/openai/deployments/your-deployment"
    }
  },
  "model": "azure/gpt-4o"
}

Google (Gemini)¶

{
  "provider": {
    "google": {
      "apiKey": "{env:GOOGLE_API_KEY}"
    }
  },
  "model": "google/gemini-2.5-pro"
}

Google Vertex AI¶

{
  "provider": {
    "google-vertex": {
      "project": "my-gcp-project",
      "location": "us-central1"
    }
  },
  "model": "google-vertex/gemini-2.5-pro"
}

Uses Google Cloud Application Default Credentials. Authenticate with:

gcloud auth application-default login

The project and location fields can also be set via environment variables:

Field	Environment Variables (checked in order)
`project`	`GOOGLE_CLOUD_PROJECT`, `GCP_PROJECT`, `GCLOUD_PROJECT`
`location`	`GOOGLE_VERTEX_LOCATION`, `GOOGLE_CLOUD_LOCATION`, `VERTEX_LOCATION`

If location is not set, it defaults to us-central1.

Tip

You can also access Anthropic models through Vertex AI using the google-vertex provider (e.g., google-vertex/claude-sonnet-4-6).

Ollama (Local)¶

{
  "provider": {
    "ollama": {
      "baseURL": "http://localhost:11434"
    }
  },
  "model": "ollama/llama3.1"
}

No API key needed. Runs entirely on your local machine.

Info

Make sure Ollama is running before starting altimate. Install it from ollama.com and pull your desired model with ollama pull llama3.1.

LM Studio (Local)¶

Run local models through LM Studio's OpenAI-compatible server:

{
  "provider": {
    "lmstudio": {
      "name": "LM Studio",
      "npm": "@ai-sdk/openai-compatible",
      "env": ["LMSTUDIO_API_KEY"],
      "options": {
        "apiKey": "lm-studio",
        "baseURL": "http://localhost:1234/v1"
      },
      "models": {
        "qwen2.5-7b-instruct": {
          "name": "Qwen 2.5 7B Instruct",
          "tool_call": true,
          "limit": { "context": 131072, "output": 8192 }
        }
      }
    }
  },
  "model": "lmstudio/qwen2.5-7b-instruct"
}

Setup:

Open LM Studio → Developer tab → Start Server (default port: 1234)
Load a model in LM Studio
Find your model ID: curl http://localhost:1234/v1/models
Add the model ID to the models section in your config
Use it: altimate-code run -m lmstudio/<model-id>

Tip

The model key in your config must match the model ID returned by LM Studio's /v1/models endpoint. If you change models in LM Studio, update the config to match.

Note

If you changed LM Studio's default port, update the baseURL accordingly. No real API key is needed — the "lm-studio" placeholder satisfies the SDK requirement.

OpenRouter¶

{
  "provider": {
    "openrouter": {
      "apiKey": "{env:OPENROUTER_API_KEY}"
    }
  },
  "model": "openrouter/anthropic/claude-sonnet-4-6"
}

Access 150+ models through a single API key.

Copilot¶

{
  "provider": {
    "copilot": {}
  },
  "model": "copilot/gpt-4o"
}

Uses your GitHub Copilot subscription. Authenticate with altimate auth.

Codespaces & GitHub Actions

In GitHub Codespaces and GitHub Actions, the machine-scoped GITHUB_TOKEN lacks models:read permission and cannot be used for GitHub Copilot or GitHub Models inference. altimate automatically skips these providers in machine environments. To use them, authenticate explicitly with altimate auth or set a personal access token with models:read scope as a Codespace secret.

Snowflake Cortex¶

{
  "provider": {
    "snowflake-cortex": {}
  },
  "model": "snowflake-cortex/claude-sonnet-4-6"
}

Authenticate with altimate auth snowflake-cortex using a Programmatic Access Token (PAT). Enter credentials as account-identifier::pat-token.

Create a PAT in Snowsight: Admin > Security > Programmatic Access Tokens.

Billing flows through your Snowflake credits — no per-token costs.

Prompt caching is applied automatically for Claude models: cache markers are placed on the system prompt and trailing messages, so repeated context in long sessions is billed at Snowflake's reduced cached-input rate (5-minute TTL; exact cache-read and cache-write rates vary by model — see Snowflake's Cortex pricing). Savings are workload-dependent: long agent sessions with large stable prefixes benefit most, while very short sessions may see little change — monitor cache_read_input/cache_write_input in Snowflake's CORTEX_FUNCTIONS_QUERY_USAGE_HISTORY/TOKENS_GRANULAR telemetry after upgrading (these columns were previously always NULL for altimate-code workloads and now populate). OpenAI models are cached automatically by Cortex itself; other model families don't support caching.

Available models (catalog verified live against Cortex on 2026-07-20):

Model	Tool Calling
`claude-sonnet-5`, `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-4-6`, `claude-opus-4-6`, `claude-sonnet-4-5`, `claude-opus-4-5`, `claude-haiku-4-5`, `claude-4-sonnet`	Yes
`openai-gpt-4.1`, `openai-gpt-5`, `openai-gpt-5.1`, `openai-gpt-5.2`, `openai-gpt-5.4`, `openai-gpt-5.4-mini`, `openai-gpt-5.4-nano`, `openai-gpt-5-mini`, `openai-gpt-5-nano`	Yes
`llama4-maverick`, `llama3.3-70b`, `llama3.1-70b`, `llama3.1-8b`	No
`mistral-large2`, `mistral-7b`	No

Snowflake deprecated deepseek-r1, mistral-large, llama3.1-405b, and snowflake-llama-3.3-70b on July 8, 2026, and has delisted claude-3-7-sonnet, claude-3-5-sonnet, openai-gpt-5-chat, llama4-scout, mixtral-8x7b, and gemini-3.1-pro — requests to these now fail.

Note

Model availability depends on your Snowflake region. Enable cross-region inference with ALTER ACCOUNT SET CORTEX_ENABLED_CROSS_REGION = 'ANY_REGION' for full model access.

Adding a model not in the list¶

Snowflake Cortex adds models faster than this list can be updated. If a model is available on your Cortex account but not yet listed above, you can register it locally without forking the CLI — add it under provider["snowflake-cortex"].models in your altimate-code.json (or .altimate-code/altimate-code.json):

{
  "provider": {
    "snowflake-cortex": {
      "models": {
        "your-new-model-id": {
          "name": "Your New Model",
          "limit": { "context": 200000, "output": 32000 },
          "tool_call": true
        }
      }
    }
  }
}

The entry merges with the built-in list, so the model appears in the picker and can be selected as snowflake-cortex/your-new-model-id. Set "tool_call": false for models that don't support tools on Cortex (Llama and Mistral today) — otherwise requests with tools will fail.

The tool_call field uses snake_case (matching the rest of the altimate-code.json schema) and maps to the picker's capabilities.toolcall. The request transform reads the same value, so a user-added model marked tool_call: true keeps tools and tool_choice in outgoing requests — and one marked tool_call: false has them stripped, the same as the built-in non-tool entries.

Databricks AI Gateway¶

Connect to Databricks serving endpoints (Foundation Model APIs) via your workspace PAT. Use Databricks-hosted Llama, Claude, GPT, Gemini, DBRX, or Mixtral for agent reasoning — billing flows through your Databricks account.

{
  "provider": {
    "databricks": {}
  },
  "model": "databricks/databricks-claude-sonnet-4-6"
}

Authenticate with altimate auth databricks and enter credentials as workspace-host::pat-token:

myworkspace.cloud.databricks.com::dapi1234567890abcdef

Or set environment variables:

export DATABRICKS_HOST=myworkspace.cloud.databricks.com
export DATABRICKS_TOKEN=dapi1234567890abcdef

Create a PAT in Databricks: Settings → Developer → Access Tokens → Generate New Token.

Supported workspace domains: *.cloud.databricks.com (AWS), *.azuredatabricks.net (Azure), *.gcp.databricks.com (GCP).

Available models:

Provider	Models
Meta Llama	`databricks-meta-llama-3-1-405b-instruct`, `databricks-meta-llama-3-1-70b-instruct`, `databricks-meta-llama-3-1-8b-instruct`
Anthropic via Databricks	`databricks-claude-sonnet-4-6`, `databricks-claude-opus-4-6`
OpenAI via Databricks	`databricks-gpt-5-4`, `databricks-gpt-5-mini`
Google via Databricks	`databricks-gemini-3-1-pro`
Databricks native	`databricks-dbrx-instruct`
Mistral (tool calls unsupported)	`databricks-mixtral-8x7b-instruct`

Note

Databricks bills directly for these models — altimate-code reports $0 cost for Databricks-routed requests since pricing depends on your Databricks contract.

Custom / OpenAI-Compatible¶

Any OpenAI-compatible endpoint can be used as a provider:

{
  "provider": {
    "my-provider": {
      "api": "openai",
      "baseURL": "https://my-llm-proxy.example.com/v1",
      "apiKey": "{env:MY_API_KEY}"
    }
  },
  "model": "my-provider/my-model"
}

Tip

This works with any service that exposes an OpenAI-compatible chat completions API, including vLLM, LiteLLM, and self-hosted inference servers.

Model Selection¶

Set your default model and a smaller model for lightweight tasks:

{
  "model": "anthropic/claude-sonnet-4-6",
  "small_model": "anthropic/claude-haiku-4-5-20251001"
}

The small_model is used for lightweight tasks like summarization and context compaction.

Provider Options Reference¶

Field	Type	Description
`apiKey`	`string`	API key (supports `{env:...}` and `{file:...}`)
`baseURL`	`string`	Custom API endpoint URL
`api`	`string`	API type (e.g., `"openai"` for compatible endpoints)
`headers`	`object`	Custom HTTP headers to include with requests
`options.region`	`string`	AWS region (Amazon Bedrock only, default: `us-east-1`)
`options.profile`	`string`	AWS named profile (Amazon Bedrock only)
`options.baseURL`	`string`	Custom endpoint URL for Bedrock gateway/proxy (Amazon Bedrock only)
`project`	`string`	GCP project ID (Google Vertex AI only)
`location`	`string`	GCP region (Google Vertex AI only, default: `us-central1`)