Model providers

Deep Agents Code supports any chat model provider compatible with LangChain, unlocking use for virtually any LLM that supports tool calling. Any service that exposes an OpenAI-compatible or Anthropic-compatible API also works out of the box—see Compatible APIs.

Quickstart

Deep Agents Code integrates automatically with the following model providers: no extra configuration needed beyond installing the relevant provider package.

1. Install provider packages

   Each model provider requires its corresponding LangChain integration package. These ship as optional extras to keep the application lightweight. OpenAI, Anthropic, and Gemini are included by default. Install any other extra from within a session with /install, or from the shell with dcode --install:

   In session

   Shell

   /install groq

   dcode --install groq

   Run /install with no argument to list the valid extras. To preinstall extras during the initial CLI install, set DEEPAGENTS_CODE_EXTRAS:

   curl -LsSf https://langch.in/dcode | DEEPAGENTS_CODE_EXTRAS="baseten,groq" bash

2. Set credentials

   Add an API key for your provider with the /auth credential manager:

   /auth

   /auth shows a list of available providers and stores credentials for reuse across sessions.

   For non-interactive runs, CI/CD, or anywhere a TUI is not available, store the same key from the shell with dcode auth set or set the provider's environment variable instead. See Provider credentials for the full key resolution order, the DEEPAGENTS_CODE_ prefix for scoping a key to Deep Agents Code, and the Provider reference for each provider's environment variable.

   To configure model parameters, see Model parameters.

Provider reference

Using a provider not listed here? See Arbitrary providers: any LangChain-compatible provider can be used in Deep Agents Code with additional setup.

dcode --install nvidia
dcode

/model --default nvidia:nvidia/nemotron-3.5-super-vl-120b-a12b

Sign in with ChatGPT

The openai_codex provider lets you use OpenAI's Codex models with your paid ChatGPT subscription instead of an OPENAI_API_KEY. You sign in with your ChatGPT account, and it shows up as its own provider in both /auth and the /model switcher, separate from the API-key-based openai provider.

Your sign-in persists across sessions. To check your status or sign out, run /auth, select openai_codex, and choose to re-authenticate or sign out.

Model routers and proxies

Model routers like OpenRouter and LiteLLM provide access to models from multiple providers through a single endpoint.

Use the dedicated integration packages for these services:

OpenRouter is a built-in provider—install the extra and use it directly:

/install openrouter

dcode --install openrouter

LiteLLM is also a built-in provider:

/install litellm

dcode --install litellm

Switch models

To switch models in Deep Agents Code, either:

1. Use the interactive model switcher with the /model command.

   Note

   Not all models appear here. If yours is missing, pass the model name directly (e.g. /model gpt-5.5) or add it to config.toml.

2. Specify a model name directly as an argument, e.g. /model gpt-5.5. You can use any model supported by the chosen provider, regardless of whether it appears in the list from option 1. The model name will be passed to the API request.

3. Specify the model at launch via --model, e.g.

   dcode --model openai:gpt-5.5

Which models appear in the switcher

The /model selector dynamically builds its list from installed provider packages. Expand below for the full criteria and troubleshooting.

Open weights models

If you want to use an open weights model, there are two common paths depending on whether you prefer local or cloud-hosted inference.

Local inference with Ollama is the easiest way to get started for free, with no API key required:

1. Install Ollama and pull a model, for example:

   ollama pull qwen3:4b

2. Install the Ollama extra:

   In session

   Shell

   /install ollama

   dcode --install ollama

3. Select the model:

   In session

   Shell

   /model

   dcode --model ollama:qwen3:4b

   Use the interactive switcher, or pass the model directly with /model ollama:qwen3:4b.

Cloud-hosted open weights via Groq gives you fast inference without running anything locally:

1. Get a free API key at console.groq.com.

2. Install the Groq extra:

   In session

   Shell

   /install groq

   dcode --install groq

3. Select a model:

   In session

   Shell

   /model

   GROQ_API_KEY="your-api-key" dcode --model groq:openai/gpt-oss-120b

   Use the interactive switcher, or pass the model directly with /model groq:openai/gpt-oss-120b.

Fireworks is another popular cloud provider for open weights models:

/install fireworks
/model

dcode --install fireworks
FIREWORKS_API_KEY="your-api-key" dcode --model fireworks:accounts/fireworks/models/deepseek-v4-pro

Use the interactive switcher, or pass the model directly with /model fireworks:accounts/fireworks/models/deepseek-v4-pro.

Baseten is another cloud provider for open weights models:

/install baseten
/model

dcode --install baseten
BASETEN_API_KEY="your-api-key" dcode --model baseten:moonshotai/Kimi-K2.7-Code

Use the interactive switcher, or pass the model directly with /model baseten:moonshotai/Kimi-K2.7-Code.

curl -LsSf https://langch.in/dcode | DEEPAGENTS_CODE_EXTRAS="fireworks" bash

Together, OpenRouter, and Hugging Face (langchain-huggingface) are other options for cloud-hosted open weights. See the Provider reference for credentials and package names.

Set a default model

You can set a persistent default model that applies to all future CLI launches:

• Via model selector: Open /model, navigate to the desired model, and press Ctrl+S to pin it as the default. Pressing Ctrl+S again on the current default clears it.

• Via command: /model --default provider:model (e.g., /model --default anthropic:claude-opus-4-8)

• Via config file: Set [models].default in ~/.deepagents/config.toml (see Configuration).

• From the shell:

  dcode --default-model anthropic:claude-opus-4-8

To view the current default:

dcode --default-model

To clear the default:

• From the shell:

  dcode --clear-default-model

• Via command: /model --default --clear

• Via model selector: Press Ctrl+S on the currently pinned default model.

Without a default, Deep Agents Code uses the most recently used model.

Model parameters

Pass extra constructor kwargs to the model—sampling controls, reasoning/thinking budgets, context window sizes, request timeouts, and anything else the underlying chat-model class accepts. Three places to set them, in priority order (highest first):

1. One-off at launch with --model-params. JSON string, session-only:

   # OpenAI reasoning effort
   dcode --model openai:gpt-5.5 --model-params '{"reasoning": {"effort": "high"}}'
   
   # Anthropic extended thinking
   dcode --model anthropic:claude-opus-4-8 --model-params '{"thinking": {"type": "enabled", "budget_tokens": 10000}, "max_tokens": 16000}'

2. Mid-session via /model --model-params. Same JSON syntax—swaps params (and optionally the model) without restarting:

   /model --model-params '{"temperature": 0.7}' anthropic:claude-opus-4-8
   /model --model-params '{"num_ctx": 16384}'           # opens selector, applies params to choice

3. Persistent in config.toml. Provider-level defaults (with optional per-model sub-tables) that apply on every launch:

   [models.providers.anthropic.params]
   thinking = { type = "enabled", budget_tokens = 10000 }
   max_tokens = 16000
   
   [models.providers.openai.params]
   reasoning = { effort = "high", summary = "auto" }
   output_version = "responses/v1"
   
   [models.providers.ollama.params]
   num_ctx = 16384
   temperature = 0
   
   # Per-model override—wins over provider-level keys
   [models.providers.ollama.params."qwen3:4b"]
   temperature = 0.5

CLI flags override config-file params and are session-only (mid-session changes are not persisted). Per-model sub-tables in config.toml override provider-level keys (shallow merge—see Model constructor params for full semantics). --model-params cannot be combined with --default.

For retry counts, prefer --max-retries or the top-level [retries] config.

To override fields on the model's runtime profile (max_input_tokens, tool_calling, capability flags)—distinct from constructor params—see Profile overrides.

Advanced configuration

For detailed configuration of provider params, profile overrides, custom base URLs, compatible APIs, arbitrary providers, and lifecycle hooks, see Config file and Hooks.