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
Mistral AI	mistral	MISTRAL_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
MiniMax	minimax	MINIMAX_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
Cloudflare Workers AI	cloudflare_workers_ai	CLOUDFLARE_API_TOKEN + CLOUDFLARE_ACCOUNT_ID
OpenRouter	openrouter	OPENROUTER_API_KEY
Perplexity Agent API	perplexity_agent	PERPLEXITY_API_KEY
Llama (local)	llama	none — local model
Refuseless	refuseless	REFUSELESS_API_KEY

Refuseless

The built-in refuseless provider uses Chat Completions at https://api.refuseless.com/v1, with REFUSELESS_API_KEY or a key saved in Settings → Providers. No custom endpoint is needed. Selecting Refuseless defaults to GLM-5.3 Abliterated (glm-5.3-abliterated); setting its key alone does not change your provider or any existing defaults.

export REFUSELESS_API_KEY="your-api-key"
kolega-code . --provider refuseless --model glm-5.3-abliterated
kolega-code models list --provider refuseless

The installed CLI does not load a target project’s .env. Export the key in the launching shell or save it in Settings instead.

All five paid routes are bundled in the shared catalog used by the Python API, CLI, TUI onboarding, Settings, /model, the Fast slot, per-agent role selectors, and configured sub-agent discovery:

Model ID	Context window (tokens)	Output limit (tokens)	Image input	Thinking efforts
glm-5.3-abliterated	1,048,576	131,072	No	low, high, max
glm-5.3-flash-abliterated	1,048,576	131,072	Yes	low, high, max
deepseek-v4.1-flash-abliterated	1,048,576	65,536	Yes	off, low, high, max
deepseek-v4.1-flash-fast	1,048,576	262,144	Yes	off, low, high, max
minimax-m3.1-flash	1,048,576	512,000	Yes	low, high, max

The primary GLM route’s context and output limits are both measured and published. GLM Flash, DeepSeek Flash Fast, and MiniMax use Refuseless’s published exact-route maxima; these are accepted catalog limits, not claims of live verification at those ceilings. Paid DeepSeek Abliterated retains its measured 65,536-token output cap, despite its model page advertising 131,072: a native-usage probe requested 131,073 tokens and finished with length at 65,536.

All routes default to low. DeepSeek’s native off disables reasoning; it is not a none alias, and medium, minimal, and xhigh are not supported. Reasoning is displayed as thinking and replayed in the native reasoning_content field across tool results, not mixed into the visible answer. Function tools run in Kolega Code; hosted search is not enabled.

The abliterated routes use Refuseless’s modified weights. DeepSeek Flash Fast and MiniMax Flash use standard weights; Fast is not an alias for the Abliterated route. Refuseless credentials, capabilities, limits, and pricing are independent of the corresponding first-party providers.

The standard-weight DeepSeek Flash Fast and MiniMax routes have been observed to exceed small requested output caps. Kolega forwards smaller caller limits unchanged, but those limits are not a reliable provider-side spending ceiling on these routes.

Refuseless uses prepaid credits. HTTP 402 and streamed insufficient_credits errors surface as billing failures, including after partial output, rather than successful truncated answers or an automatic retry loop.

Refuseless’s public pricing page publishes the five paid routes’ rates below. Kolega uses these literal USD per million tokens rates for input, cache reads, and output:

Model ID	Input	Cache read	Output
glm-5.3-abliterated	$1.00	$0.15	$2.00
glm-5.3-flash-abliterated	$0.12	$0.03	$0.50
deepseek-v4.1-flash-abliterated	$0.12	$0.025	$0.45
deepseek-v4.1-flash-fast	$0.01	$0.002	$0.08
minimax-m3.1-flash	$0.02	$0.002	$0.08

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.

GPT-6 Sol (gpt-6-sol), GPT-6 Luna (gpt-6-luna) and GPT-6.1 Sol (gpt-6.1-sol) are the rest of the GPT-6 family, also on both providers. Sol and Luna are the cheaper/faster members and accept the full none, low, medium, high, xhigh, max ladder; GPT-6.1 Sol is the near-Astra refresh and rejects none and minimal (use low). All three keep Astra’s 1,050,000-token window and 128K output reservation on the API provider and the same conservative 400,000-token budget on the ChatGPT provider.

GPT-6.1 Terra (gpt-6.1-terra) is the mid-tier member of the GPT-6.1 generation and is available on both providers. It keeps Astra’s 1,050,000-token window and 128K output reservation on the API provider, supports image input and hosted web search, and accepts none, low, medium, high, xhigh, and max reasoning efforts (medium by default) — only minimal is rejected. On the ChatGPT provider the Codex backend advertises a 500,000-token window for Terra, which leaves 372,000 input tokens after the 128K output reservation; the rest of the GPT-6 subscription models keep the conservative 400,000-token budget.

Gemini 4 Argon (gemini-4-argon) is available on the google provider. Google released Argon on October 13, 2026. It supports image input, function calling, and low, medium, and high thinking levels (medium by default). Kolega omits temperature for Argon. Unlike Gemini 3, its 1,048,576-token window is shared by input, thinking, and output. Kolega reserves 65,536 tokens for output, leaving 983,040 input tokens. The native GenerateContent integration uses bounded requests; Google’s long-decode continuation and background Interactions workflows are not enabled.

Grok 4.7 (grok-4.7) is available on the xai provider, with image input, function calling, and low, medium, high, and xhigh reasoning efforts. xAI released it on September 21, 2026. Kolega defaults to medium; xAI defaults to high when effort is omitted. Its 500,000-token context window includes input and output. Kolega reserves 32,768 output tokens, leaving 467,232 input tokens. This is Kolega’s budgeting policy, not a hard output ceiling published by xAI. Grok 4.7 Fast is not available on the public xAI API; it is exclusive to Cursor and Grok Build and is not added to this catalog.

Both are available in the main, Fast, per-agent, and vision model selectors. Adding them does not change existing provider defaults. To select either:

kolega-code . --provider google --model gemini-4-argon
kolega-code . --provider xai --model grok-4.7

Tip

Mistral AI (native API). The mistral provider calls Mistral’s own Chat Completions API at https://api.mistral.ai/v1/chat/completions, using MISTRAL_API_KEY. It is a dedicated native adapter, not an OpenRouter route or a custom OpenAI-compatible endpoint.

The picker defaults to Mistral Medium 3.5 (mistral-medium-3-5). The native catalog includes these chat/function-calling families and eligible aliases:

Family / primary model ID	Context window (tokens)	Image input	Thinking efforts
Medium 3.5 / mistral-medium-3-5	262,144	Yes	none, high
Small 4 / mistral-small-2603	262,144	Yes	none, high
Large 4 / mistral-large-4	1,048,576	Yes	none, high
Large 3 / mistral-large-2512	262,144	Yes	No control
Ministral 3 3B / ministral-3b-2512	131,072	Yes	No control
Ministral 3 8B / ministral-8b-2512	262,144	Yes	No control
Ministral 3 14B / ministral-14b-2512	262,144	Yes	No control
Codestral / codestral-2508	256,000	No	No control

Windows and capabilities mirror Mistral’s authenticated GET /v1/models, which is authoritative for what the configured account can reach. Catalog visibility still does not guarantee successful inference: a model can return HTTP 403 when the subscription tier or an organization policy excludes it. The picker also accepts the listed aliases, such as mistral-large-4-0, mistral-large-latest and mistral-code-latest; those targets are mutable and their capabilities may change.

Mistral publishes new models between Kolega Code releases. models refresh fetches the live list once and caches it locally:

kolega-code models refresh --provider mistral

The endpoint is authenticated, so the command needs MISTRAL_API_KEY or a key saved in Settings. A refresh only adds models Kolega does not already know; it never rewrites a bundled spec or the picker default. Cached entries are not marketed as the release’s reviewed set and are never marked featured. Set KOLEGA_CODE_MISTRAL_CATALOG to pin the cache path or KOLEGA_CODE_DISABLE_MISTRAL_CATALOG=1 to ignore it.

As with every provider, CLI flags must name both provider and model:

kolega-code . --provider mistral --model mistral-medium-3-5
kolega-code models list --provider mistral

Image input is enabled only on vision-capable catalog models, including Ministral 3; Codestral is text-only. Medium 3.5, Small 4 and Large 4 expose none (thinking off, the default) and high (thinking on), rather than the OpenAI effort ladder; Large 3 and the Ministral/Codestral families expose no control. Same-provider reasoning is replayed in Mistral’s native structured content format, preserving replay metadata rather than turning thinking into visible answer text. Models and their capabilities come from the shared catalog used by the main, Fast, per-agent model selectors, and subagent discovery.

Token counting is a conservative local estimate with a safety margin, not an exact Mistral tokenizer or a hosted count-tokens endpoint. It cannot guarantee an exact fit. Input and the requested output reservation share the model’s context window. The catalog reserves 32,768 output tokens for these models as Kolega’s budgeting policy, not a verified hard native maximum-output ceiling; that reservation reduces the input budget. Kolega Code owns the local function-tool loop; Mistral-hosted server tools are not enabled. A native MISTRAL_API_KEY is separate from OpenRouter/gateway credentials.

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

Moonshot (Kimi). The moonshot provider targets Moonshot’s Anthropic-compatible endpoint with MOONSHOT_API_KEY. The default is kimi-k3; kimi-k3.1-pro — the October 2026 K3.1 release, with a 1M context window — and kimi-k3.1-pro-highspeed (~2–3× output speed) are also listed. K3-series models always reason (thinking cannot be disabled), fix temperature at 1.0, and take a low/high/max reasoning-effort ladder.

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. The K3.1 release adds k3.1-pro (Plus and higher; the catalog budgets 256K because the 1M window is gated to Pro and higher) and k3.1-pro-highspeed (Pro and higher, so it always carries the full 1M window and burns about twice the quota for ~2–3× speed). Both take low/high/max effort. Set KIMI_CODING_API_KEY to your Kimi Coding Plan key.

Tip

MiniMax. The minimax provider uses MiniMax’s Anthropic-compatible endpoint (https://api.minimax.io/anthropic) with MINIMAX_API_KEY, and is distinct from the MiniMax models reachable through OpenRouter, Fireworks, or Ollama Cloud. The default is MiniMax-M3.1-Flash, which accepts text and image input with a 1M input window and a separate 524,288-token output allowance. It requires adaptive thinking, so thinking effort is tunable from low through max but cannot be disabled (none returns a 400). MiniMax-M3 shares the same window and output ceiling but does not surface reasoning as thinking blocks. The M2 generation — MiniMax-M2.7, MiniMax-M2.5, MiniMax-M2.1, MiniMax-M2 and their -highspeed variants — is text-only, always streams thinking blocks, and shares one 256K input window with its 196,608-token output allowance.

MiniMax runs two account systems: this provider targets the international platform (platform.minimax.io). Keys from the China-mainland platform (platform.minimaxi.com) are not interchangeable; to use that endpoint, add it as a custom endpoint with the anthropic API style.

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

Cloudflare Workers AI. The cloudflare_workers_ai provider uses Workers AI’s OpenAI-compatible Chat Completions endpoint, which is scoped to your account: https://api.cloudflare.com/client/v4/accounts/<account_id>/ai/v1. It needs two values:

• an API token with the Workers AI Read permission, in CLOUDFLARE_API_TOKEN or saved under Settings → Providers. Use an API token (cfut_…/cfat_…), not the Global API Key.
• your account ID, in CLOUDFLARE_ACCOUNT_ID or the Account ID field that appears under Settings → Providers (and in onboarding) when Cloudflare is selected. Find it in the Cloudflare dashboard under Workers AI → Use REST API. The environment variable wins over the saved value.

The bundled catalog lists tool-calling models with at least a 128K window, led by @cf/zai-org/glm-5.3 (the default, 1M context). It also includes GLM-5.3 Flash, GLM-5.2, GLM-4.7 Flash, Kimi K2.7 Code and K2.6, DeepSeek V4.1 Flash and V4 Pro, Qwen 3.8 27B, Gemma 4 26B A4B, Nemotron 3 120B A12B, and GPT-OSS 120B/20B. Windows, vision support, and effort ladders follow Cloudflare’s model metadata. Workers AI publishes no output ceilings, so Kolega reserves an explicit output budget inside each window and always sends it: without one, Workers AI stops after 256 tokens. To discover models published since the bundled release, run:

kolega-code models refresh --provider cloudflare_workers_ai

The refresh uses the same token and account ID and only adds tool-capable models; it never overrides bundled entries.

Many larger models require the Workers Paid plan: on the free plan, GLM-5.3 (the default), GLM-5.3 Flash, GLM-5.2, Kimi K2.7 Code and K2.6, and both DeepSeek models are refused, while GPT-OSS 120B/20B, Qwen 3.8 27B, Gemma 4 26B A4B, Nemotron 3 120B A12B, and GLM-4.7 Flash work. The free plan’s daily neuron allocation also runs out quickly under an agent. Both conditions surface as a billing error rather than a retry loop. Requests carry an x-session-affinity header so Workers AI’s prefix caching can reuse the conversation’s prompt; cached tokens are billed at the discounted rate and shown in usage.

Thinking effort follows each model’s Workers AI controls. On GLM-5.3 and GLM-5.3 Flash, low skips reasoning entirely (reasoning cannot be disabled outright). Where none is offered — DeepSeek V4.1 Flash and V4 Pro, GLM-5.2, and Kimi K2.6 — Kolega also sends the models’ enable_thinking: false switch, because some of them keep reasoning on reasoning_effort: none alone.

To route requests through an AI Gateway for logging, caching, and analytics, set CLOUDFLARE_AI_GATEWAY_ID to the gateway’s ID; Kolega adds the cf-aig-gateway-id header to every request.

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), Inkling Small, and Inkling 2 Small. These serverless routes are natively multimodal (text + image) with 256K-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, Qwen 3.7 Plus, and Ember-1 through the Settings UI and CLI. Fireworks reasoning models return reasoning_content. Kimi K3 always reasons and uses max effort. Ember-1 (accounts/fireworks/models/ember-1) is Fireworks Research’s post-trained Kimi K3 that emits ~40% shorter reasoning traces; it does expose the full none, low, medium, high, max reasoning_effort ladder. The other listed Fireworks models expose the same five 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.)

Strict tool schemas on DeepSeek

Code that calls Kolega’s LLM client directly can mark a tool definition strict=True. The Responses providers then send "strict": true with that function tool, which asks the provider to hold the tool call to the schema exactly: every required field present and nothing extra.

DeepSeek enforces this only under its beta base URL (https://api.deepseek.com/beta) and silently ignores the flag on the normal one, so Kolega sends all DeepSeek requests to the beta URL. A strict schema must list every property in required and set additionalProperties: false on each object, or DeepSeek rejects the request with a 400. Tools that are not marked strict behave as before.

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-fable-5-1	low, medium, high, xhigh, max	high
Anthropic claude-opus-5	low, medium, high, xhigh, max	medium
Anthropic claude-opus-5-5	low, medium, high, xhigh, max	medium
Anthropic claude-sonnet-5	low, medium, high, xhigh, max	medium
Anthropic claude-sonnet-5-5	low, medium, high, xhigh, max	high
DeepSeek deepseek-flash, deepseek-v4-pro	none, low, high, max	high
Moonshot kimi-k3	max	max
Moonshot kimi-k3.1-pro, kimi-k3.1-pro-highspeed	low, high, max	max
Moonshot kimi-k2.7-code	auto	auto
Moonshot kimi-k2.6	auto, none	auto
MiniMax MiniMax-M3.1-Flash	low, medium, high, xhigh, max	max
Kimi Coding Plan k3, k3-256k	max	max
Kimi Coding Plan k3.1-pro, k3.1-pro-highspeed	low, high, 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
Fireworks ember-1	none, low, medium, high, max	medium
Fireworks kimi-k3	max	max
Ollama Cloud thinking models	none, low, medium, high, max	medium
Ollama Cloud gpt-oss:*	low, medium, high	medium
Cloudflare @cf/zai-org/glm-5.3, glm-5.3-flash	low, high, max	max
Cloudflare @cf/zai-org/glm-5.2	none, high, max	max
Cloudflare @cf/deepseek-ai/deepseek-v4.1-flash-1017, deepseek-v4-pro-0813	none, low, high, max	high
Cloudflare @cf/moonshotai/kimi-k2.6	none, high	high
Cloudflare @cf/qwen/qwen3.8-27b	low, medium, xhigh	xhigh
Cloudflare @cf/openai/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
Google gemini-4-argon	low, medium, high	medium
OpenAI / ChatGPT gpt-6-astra	low, medium, high, xhigh, max	medium
OpenAI / ChatGPT gpt-6-sol, gpt-6-luna	none, low, medium, high, xhigh, max	medium
OpenAI / ChatGPT gpt-6.1-sol	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.7	low, medium, high, xhigh	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.