Use another model: Gemini, Claude, Grok, DeepSeek or a local one, in the same harness

Almost nothing in the room is OpenAI-specific. Swap the model for DeepSeek, or for Claude or Gemini through LiteLLM, and the tools, sessions, guardrails, approval gate, harness, container and end-to-end checks stay exactly as they are. ¹ This page is the swap, taken from the book's own concept and verified against the installed SDK, so that a person who does not want to use OpenAI, or wants a model on their own machine, can still run every other page in this room.

Two paths, one rule

The SDK supports any OpenAI-API-compatible model through a base URL plus API key swap; for providers that only speak their own API, it ships LiteLLM as an optional extra. The rule for which path to take: ¹

Since the book was written, the providers people ask for most all publish an OpenAI-compatible endpoint as well, so both paths reach them; the sections below on Claude and Grok say which path each provider recommends and what was verified here.

The minimum change is not the model string and not a reinstall: it is a client pointed at the right endpoint, and a typed model object passed where a string went before. ¹

Path 1: the base-URL swap

The book's models.py, which defaults to OpenAI and swaps both tiers to DeepSeek when a DEEPSEEK_API_KEY exists: ¹

# src/chat_agent/models.py
import os

from openai import AsyncOpenAI

from agents import OpenAIChatCompletionsModel

# NOTE: do not call set_tracing_disabled(True) here. The CLI decides per-run
# via RunConfig(tracing_disabled=...) based on whether an OPENAI_API_KEY is
# set. A global disable would silently shut off tracing even after a learner
# adds an OpenAI key later.

# Default to OpenAI on the standard client (the chapter's primary path).
# If DEEPSEEK_API_KEY is set, swap both models to the DeepSeek endpoint
# via the OpenAI-compatible client. Call sites stay identical either way:
# Agent(model=flash_model, ...) accepts a string or a typed model object.
flash_model: str | OpenAIChatCompletionsModel = "gpt-5.4-mini"
pro_model: str | OpenAIChatCompletionsModel = "gpt-5.5"

deepseek_key: str | None = os.environ.get("DEEPSEEK_API_KEY")
if deepseek_key:
    deepseek_client: AsyncOpenAI = AsyncOpenAI(
        api_key=deepseek_key,
        base_url="https://api.deepseek.com",
    )
    flash_model = OpenAIChatCompletionsModel(
        model="deepseek-v4-flash",
        openai_client=deepseek_client,
    )
    pro_model = OpenAIChatCompletionsModel(
        model="deepseek-v4-pro",
        openai_client=deepseek_client,
    )

Then pass the model object instead of a string anywhere you have Agent(...); everything else works identically. ¹ In this room that is one line in the factory on the build page: Agent(name=..., instructions=..., tools=[...], model=flash_model).

The names change, the pattern does not: the book's economy model is today's cheapest OpenAI-compatible one, and if it is not when you read this, search for the current one and swap the model string. The mechanism the code depends on is only the client and the base URL. ¹

The same swap reaches Gemini and a local model. Google publishes an OpenAI-compatible endpoint for the Gemini API, in beta while feature support is extended, with function calling and structured output supported: ²

# Gemini through its OpenAI-compatible endpoint (verified 2026-09-04)
gemini_client = AsyncOpenAI(
    api_key=os.environ["GEMINI_API_KEY"],
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
)
flash_model = OpenAIChatCompletionsModel(model="gemini-2.5-flash", openai_client=gemini_client)

# A model on your own machine, behind any OpenAI-compatible local server
# (verified 2026-09-04 with llama.cpp's llama-server on 127.0.0.1:8081)
local_client = AsyncOpenAI(api_key="local", base_url="http://127.0.0.1:8081/v1")
flash_model = OpenAIChatCompletionsModel(model="qwen2.5-0.5b-instruct", openai_client=local_client)

Path 2: LiteLLM, for any model

Some models you will want do not offer an OpenAI-compatible endpoint at all; LiteLLM puts Anthropic, Google, AWS Bedrock, Mistral, local Ollama and many more behind one model object, as an optional extra: ¹

uv add "openai-agents[litellm]"

Then construct a LitellmModel exactly where you constructed OpenAIChatCompletionsModel before. The provider lives in the model string as a provider/model prefix; the key is passed in directly: ¹

# src/chat_agent/models.py (the any-provider path)
import os

from agents.extensions.models.litellm_model import LitellmModel

# Claude, via Anthropic's native API:
claude_model = LitellmModel(
    model="anthropic/claude-4.5-sonnet",        # provider/model; verify the current id
    api_key=os.environ["ANTHROPIC_API_KEY"],
)

# Gemini, Bedrock, Ollama, and the rest follow the same shape:
# LitellmModel(model="gemini/...", api_key=os.environ["GEMINI_API_KEY"])

A LitellmModel is a model object, so the call site is unchanged; it drops straight into Agent(model=...). ¹ The SDK documentation adds that a litellm/... model name string also works in place of the object, and that some providers reached through LiteLLM do not populate usage metrics unless you pass ModelSettings(include_usage=True). ³

Claude (Anthropic)

Anthropic publishes an OpenAI SDK compatibility layer: point the client at https://api.anthropic.com/v1/ with a Claude API key and a Claude model name. Anthropic says the layer is primarily intended to test and compare model capabilities, is not considered a long-term or production-ready solution for most use cases, and recommends its native API for the full feature set. ⁴ So the two paths split by depth:

# Claude, demo depth: Anthropic's OpenAI-compatible endpoint (route verified 2026-10-12)
claude_client = AsyncOpenAI(
    api_key=os.environ["ANTHROPIC_API_KEY"],
    base_url="https://api.anthropic.com/v1/",
)
flash_model = OpenAIChatCompletionsModel(model="claude-haiku-5-5", openai_client=claude_client)

# Claude, production depth: the native API through LiteLLM (route verified 2026-10-12)
from agents.extensions.models.litellm_model import LitellmModel

flash_model = LitellmModel(model="anthropic/claude-haiku-5-5", api_key=os.environ["ANTHROPIC_API_KEY"])

Four things the compatibility layer does differently, from Anthropic's own table, each one a test to write before relying on it: ⁴

• strict on a function tool is ignored, so tool arguments are not guaranteed to match the schema; validate them in the tool body, which this room does anyway (build page).
• response_format is ignored, so a typed output is not enforced by the provider; parse and validate the output in code.
• temperature and top_p: on Claude 4.7 and later models, a temperature below 1 or any top_p other than the default returns a 400 error. Leave both out of ModelSettings.
• Forced tool use: tool_choice="required" or a named function returns an error on Claude Opus 5.5, Sonnet 5.5, Fable 5.1 and Mythos 5.1; keep tool_choice at "auto" on those models.

The model id is never guessed: list the account's models first, as the key check below shows, and use an id the list returns.

Grok (xAI)

xAI's API takes the OpenAI SDK with the base URL https://api.x.ai/v1 and a key read from XAI_API_KEY, and its function-calling examples use the Responses API. ⁵ xAI recommends the Responses API and labels its Chat Completions endpoint deprecated, a legacy endpoint with limited updates. ⁶ The Agents SDK speaks the Responses API natively, so Grok takes OpenAIResponsesModel with the xAI client, and OpenAIChatCompletionsModel only as a fallback:

# Grok through xAI's Responses API (route verified 2026-10-12)
from agents import OpenAIResponsesModel

xai_client = AsyncOpenAI(api_key=os.environ["XAI_API_KEY"], base_url="https://api.x.ai/v1")
flash_model = OpenAIResponsesModel(model="grok-4.7", openai_client=xai_client)

# LiteLLM reaches the same provider with an xai/ prefix (route verified 2026-10-12)
flash_model = LitellmModel(model="xai/grok-4.7", api_key=os.environ["XAI_API_KEY"])

The text model ids on xAI's pricing page on 2026-10-12 included grok-4.7, grok-4.6, grok-4.5 and grok-4.3; that page did not say which support tool calling, so the first live call with a tool is the test. ⁷ One symptom to know: an invalid xAI key answers 400, "Incorrect API key provided", not 401, so a 400 on the first call is a key problem before it is a request problem. ⁸

Gemini on the free tier

A free tier is a real choice for a demo, with two limits that decide the build:

• Not every listed model is open to every account. In the mortgage demo of 2026-10-12, gemini-2.5-flash was refused as unavailable to new users and gemini-3.1-flash-lite answered. ⁹ List the models with the key you will use, then make one live call to the one you choose, before writing its id into code.
• The quota is small and per model. Size the build to it: offline and scripted tests first, a fixed number of live calls written in progress.md before the first one, and a stop, never a silent switch to a paid model, when the quota runs out.

The key the owner placed on 2026-10-12 began AQ. rather than AIza, and worked; check a Gemini key against the models endpoint rather than by its prefix alone. ⁸

Before the first call: check the key, then the endpoint

API key strings often get pasted around with the wrong label; two minutes on the prefix saves an hour of 401s: ¹

Then a read-only probe of the provider's models endpoint, which costs nothing and says in one second whether the key and the variable name are right; the book's example is OpenAI's, and the same idea lists the current Gemini ids so the model string is never guessed: ¹

curl -s https://api.openai.com/v1/models -H "Authorization: Bearer $OPENAI_API_KEY" | head -c 200
curl -s "https://generativelanguage.googleapis.com/v1beta/models" -H "x-goog-api-key: $GEMINI_API_KEY" | head -c 400

Send a key in a header rather than in the address where the provider allows it; an address ends up in logs. Claude and Grok list their models through the same OpenAI-compatible clients shown above (await client.models.list()).

load_dotenv() must run before any module that reads these variables, or the failure is a confusing KeyError deep in an import chain. ¹

Two caveats that bite

Tracing. A non-OpenAI model still produces traces locally, but uploading them to OpenAI's dashboard needs an OPENAI_API_KEY; on a LiteLLM-only or local setup, keep the per-run tracing_disabled pattern derived from whether that key is set, or point traces at your own collector. ¹ The SDK documentation lists the same choices, set_tracing_disabled(disabled=True), set_tracing_export_api_key(...), or a custom processor, and names the symptom when you forget: 401 errors from the trace upload. ³

The Responses API. Providers that do not support it need the Chat Completions shape: set_default_openai_api("chat_completions"), or the OpenAIChatCompletionsModel used above. Some providers also reject the json_schema parameter while supporting JSON output, which can produce malformed structured responses; test typed output against the provider you chose before relying on it. ³

Which model for which agent

Picking the right model per agent, not per app, is the biggest cost knob you have, and the SDK makes the swap a one-line change. Default to economy and escalate only the rows marked frontier: ¹

Different agents in one app can use different models, and handoffs cross the boundary cleanly. Where the cheap tier holds up, keep it there; where it visibly struggles, escalate to the frontier on that specific agent. ¹ Read the meter after each run with result.context_wrapper.usage, which exposes requests, input_tokens, output_tokens and total_tokens. ¹

What was verified, and what was not

Run on 2026-09-04 against openai-agents 0.22.0 with the litellm extra (litellm 1.83.0), tracing disabled, one agent with one function tool and the question "What plan is account acct_1001 on?": ¹⁰

The local row is the honest limit: the wiring is proven, but a half-billion parameter model is not a tool-calling model. For a local worker with tools, run a model that supports function calling and re-run the probe above; the harness does not change. ¹¹ DeepSeek was not exercised here, because this record holds no key for it; its code is the book's, unchanged.

Run again on 2026-10-12 against openai-agents 0.23.1 (litellm 1.83.0), tracing disabled, with the same agent and question. This record holds no paid Claude or Grok key, so those rows prove the route, not the answer: each was called with a deliberately invalid key, and a reply from the provider's own authentication proves the client, the base URL and the request shape reached the right service without spending anything. ⁸

The first build on a real Claude or Grok key runs the probe on its own first call and records the result in its progress.md; until then, a worker on those providers has a proven route and an unproven answer, and says so.

What changes in the room, and what does not

Continue with the build page; every page after it reads the same whichever model answers.