Providers & Models

Kolega Code is provider-agnostic. You choose which LLM provider to use and which model to use for each of several roles.

Provider breadth is table stakes; Kolega Code’s extra control is assigning models by operational role and by agent role, so cheap/fast models can investigate while stronger models plan, build, or think.

Supported providers

The agent runtime recognizes these providers, plus any server you point it at via Custom Endpoints (custom:<id>, OpenAI / Responses / Anthropic-compatible):

Provider	Identifier	API key variable
Anthropic	anthropic	ANTHROPIC_API_KEY
OpenAI	openai	OPENAI_API_KEY
OpenAI (ChatGPT subscription)	openai_chatgpt	none — sign in with ChatGPT
Google	google	GOOGLE_API_KEY
Groq	groq	GROQ_API_KEY
Together.ai	together	TOGETHER_API_KEY
Fireworks.ai	fireworks	FIREWORKS_API_KEY
x.ai (Grok)	xai	XAI_API_KEY
DashScope (Alibaba)	dashscope	DASHSCOPE_API_KEY
Moonshot (Kimi)	moonshot	MOONSHOT_API_KEY
DeepSeek	deepseek	DEEPSEEK_API_KEY
Z.AI (GLM Coding Plan)	zai	ZAI_API_KEY
Kimi Coding Plan	kimi_coding	KIMI_CODING_API_KEY
Thinking Machines	thinking_machines	TINKER_API_KEY
Tinker	tinker	TINKER_API_KEY
Ollama Cloud	ollama_cloud	OLLAMA_API_KEY
OpenRouter	openrouter	OPENROUTER_API_KEY
Perplexity Agent API	perplexity_agent	PERPLEXITY_API_KEY
Llama (local)	llama	none — local model

GPT-6 Astra (gpt-6-astra) is available in the model picker for both openai and openai_chatgpt. It supports image input, hosted web search, and reasoning efforts from low through max, with medium as the Kolega Code default. Reasoning cannot be disabled for Astra. The API provider uses its 1,050,000-token context window with 128,000 tokens reserved for output. The ChatGPT provider keeps a conservative 400,000-token budget (272,000 input tokens), matching the existing subscription models. Subscription availability depends on your account and OpenAI’s rollout.

Tip

Z.AI GLM Coding Plan. The zai provider targets Z.AI’s Anthropic-compatible endpoint (https://api.z.ai/api/anthropic) and exposes GLM-5.3 (default), GLM-5.2 and GLM-5.1. Set ZAI_API_KEY to your GLM Coding Plan key (the key Z.AI also documents as ANTHROPIC_AUTH_TOKEN).

Tip

Kimi Coding Plan. The kimi_coding provider targets Kimi’s Anthropic-compatible coding endpoint (https://api.kimi.com/coding/), which is separate from the standard Moonshot API used by the moonshot provider. It exposes k3 (256K context on Moderato and higher plans; the same ID carries up to 1M on Allegretto and higher), k3-256k (a fixed 256K K3 route with roughly half the quota burn), and kimi-for-coding (the default because it is available on every plan). The K3 IDs use deep thinking with fixed max effort. kimi-for-coding-highspeed (K2.7 Code HighSpeed, Allegretto and higher) is also available. With thinking effort auto (enabled) the kimi-for-coding IDs route to K2.7 Code, and with none (disabled) they route to K2.6. Set KIMI_CODING_API_KEY to your Kimi Coding Plan key.

Tip

Ollama Cloud. The ollama_cloud provider uses Ollama Cloud’s direct OpenAI-compatible API at https://ollama.com/v1 with OLLAMA_API_KEY. Kolega Code uses the direct API model IDs returned by Ollama, such as glm-5.2 and gpt-oss:120b, rather than local Ollama aliases such as :cloud or -cloud.

The bundled catalog is generated from https://ollama.com/v1/models plus each model’s metadata from https://ollama.com/api/show. Models are included only when Ollama reports both the completion and tools capabilities. To discover eligible models published since the bundled release, run:

kolega-code models refresh --provider ollama_cloud

The runtime cache is additive: it adds IDs missing from the bundled release but never removes bundled IDs or overwrites their reviewed metadata. Startup never contacts Ollama. Retired bundled IDs disappear only when a new release snapshot is generated from Ollama’s current catalog.

Tip

OpenRouter. The openrouter provider reaches OpenRouter’s OpenAI-compatible endpoint (https://openrouter.ai/api/v1) with OPENROUTER_API_KEY. Unlike the other providers, OpenRouter is a gateway in front of many vendors, so Kolega Code ships a generated catalog of every tool-capable OpenRouter model — a model that cannot call tools cannot run the agent, so it is deliberately excluded.

Model IDs are vendor/model, for example anthropic/claude-opus-5 or z-ai/glm-5.2. OpenRouter’s routing suffixes pass straight through, so :free, :nitro and :floor variants work as their own IDs. :free endpoints are heavily rate limited and are best kept for experiments rather than long sessions.

Because the catalog runs to hundreds of entries, the Settings picker (the main Model dropdown and every Agent Models row) leads with OpenRouter’s 20 most-used models, in the order of OpenRouter’s own LLM Leaderboard, and then offers an Other… option where you can type any catalogued model id directly. /model and the sub-agent model catalog stay most-used-only. Every catalogued model still works — pass the exact ID:

kolega-code models list --provider openrouter        # the whole catalog, most-used first
kolega-code models list --provider openrouter --featured
kolega-code --provider openrouter --model deepseek/deepseek-v3.2

or /model deepseek/deepseek-v3.2 in the TUI, KOLEGA_CODE_MODEL, or settings.json. The bundled catalog is a snapshot taken at release time; to pick up models published since then, run kolega-code models refresh. That caches OpenRouter’s current model list locally and merges it at startup. Cached models are usable by ID but never join the featured list, and startup itself never touches the network.

Two behaviours are specific to this provider:

• No max_tokens is sent. On a gateway an output cap is a routing hint that excludes every upstream with a lower cap, biasing routing and price. The one exception is DeepSeek models, which always carry an explicit 64000-token cap: their real output ceiling is far below the published value and the server truncates silently without one, so the cap doubles as a deliberate filter for upstreams that report truncation honestly.
• Prompt caching is automatic. Kolega Code sends OpenRouter’s top-level cache_control breakpoint, so Anthropic-, Vertex- and Bedrock-backed models get prompt caching with no extra configuration.

Routing preferences are not set by default, because any of them narrows which upstreams may serve a request. Opt in with KOLEGA_CODE_OPENROUTER_PROVIDER_ORDER and KOLEGA_CODE_OPENROUTER_PROVIDER_ONLY (comma-separated provider slugs).

Tip

Thinking Machines. The thinking_machines provider targets Thinking Machines Lab’s Tinker API through its Anthropic-compatible endpoint (https://tinker.thinkingmachines.dev/services/tinker-prod/anthropic/api) with TINKER_API_KEY, exposing Inkling (default) and Inkling Small. Both are open-weights, natively multimodal (text + image) models with up to 1M token context, and reasoning is on by default: thinking blocks stream into the transcript, and the thinking effort picker offers none, low, medium, high, xhigh, and max (effort rides in Tinker’s output_config.effort field; none disables reasoning). Tool use, streaming, and count_tokens all work through this endpoint. Note that the Tinker Anthropic-compatible endpoint is still in beta (low-traffic, no prompt caching — cache_control is ignored), so treat it as best for personal use and experiments.

Tip

Tinker (native sampling). The tinker provider drives Tinker’s native SamplingClient (the official SDK) instead of the compatible endpoints, so the agent loop runs on the exact rendered prompts, sampled token ids, per-token behavior logprobs, stop reasons, and prefix-cache metadata that on-policy RL needs. It requires the optional native stack — pip install 'kolega-code[tinker]' (torch and the official renderers) — and authenticates with the same TINKER_API_KEY.

Any base model from Tinker’s catalog is selectable (Qwen/Qwen3-8B is the default), and fine-tuned checkpoints work by sampler weights path: --provider tinker --model tinker://<run-id>:train:<n>/sampler_weights/<step>. The provider resolves a checkpoint’s base model at runtime and uses that base’s specs (context window, vision, thinking effort). Effort is renderer-level: the Inkling family accepts none/low/medium/high/xhigh/max (mapped to tml-renderers effort floats); other bases offer thinking on/off.

The catalog is generated from Tinker’s published models.json and can be refreshed without waiting for a release: kolega-code models refresh --provider tinker.

An optional structured trace sink (LLMClient(trace_sink=...)) records the native model input, sampled tokens, logprobs, stop reason, cache usage, model/checkpoint identity, and request role per call — the RL hand-off point. Known limitations of the native path: no server-side streaming (output is replayed token-wise after the sample completes), no tool_choice (tool calls depend on the renderer’s parser, which may omit ids), and token counting is client-side via the model’s own tokenizer.

Tip

Perplexity. The perplexity_agent provider targets the Agent API (https://api.perplexity.ai/v1, Responses-compatible) with PERPLEXITY_API_KEY and reaches models from several vendors through one key — openai/gpt-5.6-sol, anthropic/claude-opus-5, google/gemini-3.6-flash, xai/grok-4.6, and perplexity/sonar among them. Kolega Code owns the agent/tool loop; the API is the model transport:

kolega-code --provider perplexity_agent --model anthropic/claude-opus-5

The catalog is a generated snapshot; pick up newer ids without waiting for a release with kolega-code models refresh --provider perplexity_agent.

(Perplexity also offers a raw-inference Gateway at https://api.perplexity.ai/router/v1; it is in limited preview with request-based access and is not shipped as a provider.)

The Agent API also runs server-side tools that Perplexity executes inside the request (web_search, fetch_url, finance_search, people_search). These are a property of the service — always enabled for perplexity_agent models, like the hosted web search on the DeepSeek/OpenAI Responses models — and are separate from Kolega Code’s local tools (read/edit/shell/…). They follow the web tool mode: client and off disable them in favor of the client-side (or no) web tools.

Tip

Fireworks.ai. The fireworks provider targets Fireworks’ OpenAI-compatible serverless endpoint (https://api.fireworks.ai/inference/v1) with FIREWORKS_API_KEY. Fireworks model IDs use resource names such as accounts/fireworks/models/glm-5p2. Kolega Code exposes Kimi K3, GLM-5.2, GLM-5.1, Kimi K2.7 Code, DeepSeek V4 Pro/Flash, MiniMax M3, and Qwen 3.7 Plus through the Settings UI and CLI. Fireworks reasoning models return reasoning_content. Kimi K3 always reasons and uses max effort; the other listed Fireworks models expose none, low, medium, high, and max as reasoning_effort values.

Note

The full Settings screen in the TUI is generated from Kolega Code’s model registry, so new entries in the supported model catalog appear there automatically. You can also select any supported provider/model through environment variables and CLI flags. See Settings & API Keys.

Model roles

Rather than one model for everything, Kolega Code uses two model slots, so you can match cost and capability to the job:

Role	Purpose	When unset
Long context	The main coding model — drives the conversation and most work	The active model you selected
Fast	Quick, cheap utility calls (e.g. web_fetch’s page-answering stage)	Inherits the active model

An unset slot inherits the active model, so out of the box both run on your main model. Pin the Fast slot when you want a cheaper or different model for that work — Settings shows which model each slot currently resolves to, so an inherited slot is never a surprise.

Set models per role

In the TUI, open Settings → Models → Model Slots (or /model) and give the Fast row a provider and model. Leave a row on Default (inherit) to keep it following the active model.

A slot may use a different provider from your main model — for example a DeepSeek main model with Anthropic Haiku for fast utility calls. That provider needs its own API key: add it under Settings → Providers, which lists every provider with its credential status and lets you set up more than one before applying. Settings refuses to apply a slot whose provider has no credential.

Equivalently, from the command line:

kolega-code . \
  --provider anthropic --model claude-opus-5 \
  --fast-provider anthropic --fast-model claude-haiku-4-5-20251001 \
  --thinking-effort medium

Or with environment variables — see Environment Variables for the complete list.

How a model gets chosen

For each role, Kolega Code resolves the provider and model in this order (first match wins):

1. CLI flags — e.g. --provider, --model, --fast-model, …
2. Environment variables — e.g. KOLEGA_CODE_PROVIDER, KOLEGA_CODE_MODEL, the per-role variants, and a project-local .env file.
3. Saved slot — the Fast/Thinking provider and model saved in Settings.
4. The active model — the provider/model selected in Settings.

Provider and model are always given together. A flag or environment variable that names only one of them is an error: no model is defaulted from a provider, and no provider is inferred from a model id — the same id can be served by different providers on different credentials, so choosing one would silently choose an account.

A configuration is only valid if a provider/model has been selected and every role’s provider has an API key available (the local llama provider needs none). If a key is missing, the CLI reports exactly which environment variable is required.

Per-agent models

The three slots above describe operational roles (main, fast, thinking). Separately, you can give each agent its own model, so a cheap, fast model handles investigation while a stronger model does the building. This applies to top-level agents and to the sub-agents they dispatch.

Agent role	Key	Runs
Planning	planning	The plan-mode agent
Building	building	The main coder agent
Investigation	investigation	Read-only research/exploration sub-agents
General	general	General-purpose sub-agents
Browser	browser	Browser/web sub-agents

Each role inherits the active (long-context) model unless you give it an override — so with nothing configured, behavior is unchanged.

In the full Settings screen, the Agent Models category lets you select a role and set its provider, model, and effort. Leave a role on Default to inherit; pick a provider, model, and thinking effort to override it.

The Browser role requires a model whose catalog entry supports vision. It does not fall back to another model or run in a text-only mode. If Default resolves to a non-vision model, Settings shows a warning and the browser agent fails with a configuration error when dispatched. Select an explicit vision-capable Browser model to enable it.

Or use environment variables, named KOLEGA_CODE_<ROLE>_PROVIDER / _MODEL / _EFFORT:

# Use a fast model for investigation; everything else uses the active model.
export KOLEGA_CODE_INVESTIGATION_PROVIDER=deepseek
export KOLEGA_CODE_INVESTIGATION_MODEL=deepseek-flash
export KOLEGA_CODE_INVESTIGATION_EFFORT=high

# Browser overrides must name a vision-capable model.
export KOLEGA_CODE_BROWSER_PROVIDER=anthropic
export KOLEGA_CODE_BROWSER_MODEL=claude-sonnet-4-6

Resolution order for a role (first match wins): env var → saved Settings → the active model. Each override’s provider must have an API key, exactly like the main roles. (Inside a run_workflow script, an explicit model=/effort= on an agent() call still takes precedence over these per-role defaults.)

Thinking effort

DeepSeek V4.1 Flash

The released model is served under DeepSeek’s canonical deepseek-flash id, appears as DeepSeek V4.1 Flash in the model picker, and is DeepSeek’s default model in Kolega. DeepSeek says V4.1 Flash surpasses V4 Pro on performance, cost, speed, and total time, and routes every other first-party id to it — including deepseek-v4-pro from 12:00 Beijing Time on September 14, 2026.

kolega-code --provider deepseek --model deepseek-flash

deepseek-v4.1-flash is not an accepted id: DeepSeek’s /models lists exactly deepseek-flash and deepseek-v4-pro, which are the two models Kolega offers for this provider. DeepSeek still accepts the retired deepseek-v4-flash, deepseek-v4-flash-vision-exp, and deepseek-v4.1-flash-expires-on-0910 ids, but they name nothing distinct (every one of them is served by V4.1 Flash), so Kolega no longer lists them; settings or sessions still naming one fall back to the DeepSeek default (deepseek-flash), and passing one explicitly fails with a “not available for” error.

Live API checks on September 10, 2026 confirmed Responses API access, image input, function calls, and none/low/high/max reasoning effort (default: high). The measured context limit is 1,048,576 tokens; Kolega applies the Flash-family 1,000,000-token budget so the input budget retains margin under that hard ceiling. The API rejects max_output_tokens above 393,216, so Kolega keeps the conservative 384,000-token output budget.

Hosted web search is not available on this route. DeepSeek removed it silently with the V4.1 release: on September 9, 2026 their Responses guide still listed web_search as “Supported, executed on the server side” and accepted it under tool_choice; on September 10 both entries read Ignored. Nothing in DeepSeek’s release notes, news page, or FAQ mentions the change. Live probes return no web_search_call items — the model answers that it has no search tool even when the tool is declared. Kolega therefore does not offer the /web toggle for deepseek-flash or the retired flash ids. Results from searches made by older models still replay into context. deepseek-v4-pro still executes hosted search today, and keeps the toggle until DeepSeek routes it to V4.1 Flash on September 14 — expect to revisit it then.

Supported effort values

Thinking effort is model-specific. Kolega Code validates the selected value against the active model and resets it to the new model’s default when you switch models in the TUI.

Provider/model	Values	Kolega Code default
Anthropic claude-fable-5	low, medium, high, xhigh, max	medium
Anthropic claude-opus-5	low, medium, high, xhigh, max	medium
Anthropic claude-sonnet-5	low, medium, high, xhigh, max	medium
DeepSeek deepseek-flash, deepseek-v4-pro	none, low, high, max	high
Moonshot kimi-k3	max	max
Moonshot kimi-k2.7-code	auto	auto
Moonshot kimi-k2.6	auto, none	auto
Kimi Coding Plan k3, k3-256k	max	max
Kimi Coding Plan kimi-for-coding, kimi-for-coding-highspeed	auto, none	auto
Z.AI glm-5.3	high, max	max
Z.AI glm-5.3-flash	high, max	max
Z.AI glm-5.2	high, max	max
Z.AI glm-5.1	auto, none	auto
Fireworks serverless reasoning models	none, low, medium, high, max	medium
Ollama Cloud thinking models	none, low, medium, high, max	medium
Ollama Cloud gpt-oss:*	low, medium, high	medium
Google gemini-3.8-flash	low, medium, high	medium
Google gemini-3.7-flash	low, medium, high	medium
Google gemini-3.6-flash	minimal, low, medium, high	medium
Google gemini-3.5-flash-lite	minimal, low, medium, high	minimal
Google gemini-3.5-flash	minimal, low, medium, high	medium
Google gemini-3.1-pro-preview	low, medium, high	high
OpenAI / ChatGPT gpt-6-astra	low, medium, high, xhigh, max	medium
OpenAI gpt-5.6-*	none, low, medium, high, xhigh, max	medium
OpenAI gpt-5.5	minimal, low, medium, high, xhigh	medium
OpenAI gpt-5.4*	minimal, low, medium, high	medium
OpenAI gpt-5.3-codex-spark	minimal, low, medium	low
xAI grok-4.5	low, medium, high	medium
xAI grok-4.3	none, low, medium, high	low

Check what’s active

kolega-code doctor --project .

doctor prints the resolved provider/model for each role (long, fast, thinking) and whether the necessary API keys are present.