Models

Deep Agents work with any LangChain chat model that supports tool calling.

Supported models

Specify models in provider:model format (for example, google:gemini-3.6-flash, openai:gpt-5.4, or anthropic:claude-sonnet-4-6). The provider prefix selects the LangChain integration, and everything after the colon is passed through to that provider as the model identifier. For valid provider strings, see initChatModel. For provider-specific configuration, see chat model integrations.

The model identifier must match the format expected by the provider. Some providers use simple names like gpt-5.5; others use namespaced IDs or deployment paths like zai-org/GLM-5.2, so the full Deep Agents string would be baseten:zai-org/GLM-5.2. Check the provider's model catalog or integration docs for the current identifiers.

Suggested models

These models perform well on the Deep Agents eval suite, which tests basic agent operations. Passing these evals is necessary but not sufficient for strong performance on longer, more complex tasks.

Open-weight models are available through providers like OpenRouter and Ollama.

Model evaluations

The Deep Agents eval suite tests popular models:

For more information, see the Eval runs.

Configure model parameters

Pass a model string to createDeepAgent in provider:model format, or pass a configured model instance for full control. Under the hood, model strings are resolved via init_chat_model.

To configure model-specific parameters, use init_chat_model or instantiate a provider model class directly:

import { initChatModel } from "langchain/chat_models/universal";
import { createDeepAgent } from "deepagents";

const model = await initChatModel("google:gemini-3.6-flash", {
  reasoningEffort: "medium", // [!code highlight]
});
const agent = createDeepAgent({ model });

import { ChatGoogle } from "@langchain/google";
import { createDeepAgent } from "deepagents";

const model = new ChatGoogle({
  model: "gemini-3.1-pro-preview",
  reasoningEffort: "medium", // [!code highlight]
});
const agent = createDeepAgent({ model });

Provider profiles

A ProviderProfile packages initialization parameters that apply when you provide a provider:model string when creating the deep agent. It does not apply when you pass a preconfigured model with init_chat_model.

You can register at two levels, and both can coexist:

• Provider level: a bare provider key like "openai" applies to every model from the openai provider.
• Model level: a provider:model key like "openai:gpt-5.4" applies only to that specific model, and merges on top of any matching provider-level profile.

See Profiles for the full field list, merge semantics, and plugin packaging.

OpenAI and the Responses API

When you pass an openai:... string as the model, Deep Agents uses the built-in OpenAI provider profile to enable the Responses API by default. That path supports OpenAI conversation state and related features; see the OpenAI provider and chat model docs for current API options.

Use the OpenAI chat integration to choose the Responses API versus Chat Completions (useResponsesApi, model kwargs, and any storage or output options your version exposes). Pass the resulting model instance to createDeepAgent({ model }) so those settings are preserved.

Select a model at runtime

If your application lets users choose a model (for example using a dropdown in the UI), use middleware to swap the model at runtime without rebuilding the agent.

import { createMiddleware, initChatModel } from "langchain";
import { createDeepAgent } from "deepagents";
import * as z from "zod";

const contextSchema = z.object({
  model: z.string(),
});

const configurableModel = createMiddleware({
  name: "ConfigurableModel",
  wrapModelCall: async (request, handler) => {
    const modelName = request.runtime.context.model;
    const model = await initChatModel(modelName);
    return handler({ ...request, model });
  },
});

const agent = await createDeepAgent({
  model: "google:gemini-3.6-flash",
  middleware: [configurableModel],
  contextSchema,
});

// Invoke with the user's model selection
const result = await agent.invoke(
  { messages: [{ role: "user", content: "Hello!" }] },
  { context: { model: "openai:gpt-5.5" } },
);

Learn more

• Models in LangChain: chat model features including tool calling, structured output, and multimodality