Models

What happens when you switch AI models mid-conversation?

Within one lab, the new model re-reads the whole conversation. Across labs it often can't, so something has to brief it.

Yes, in most apps you can switch AI models mid-conversation, and the next reply uses the new one. In Claude you can change the model, effort or thinking at any point in a chat; in Claude Code and the Codex CLI, /model switches mid-session. ChatGPT is the exception: its picker is now a thinking-level slider over one model rather than a list of models. What the new model knows depends on whether it can read the old conversation. Within one lab, for example Claude Sonnet 5.5 to Claude Opus 5.5, the new model re-reads the whole transcript, but it starts without the previous model's prompt cache, so the first reply after a switch costs more. Across labs, for example Claude to GPT or GPT to Grok, the conversation often can't move as it is, because each lab keeps its own format and its own encrypted reasoning. Something has to brief the new model. In Poly (usepoly.co) that briefing is called a catch-up: the messages the new model missed, verbatim when the gap is short and summarized when it is long.

Key takeaways

  • Claude, Claude Code, Codex and GitHub Copilot all let you switch models mid-chat as of October 2026.
  • Models don't remember anything. The app re-sends the conversation on every turn, so what carries over is whatever the app can re-send.
  • The first turn after a switch costs more: the new model has no prompt cache for the conversation yet.
  • Check the context window before switching to a smaller model deep into a long conversation.
  • Whatever the conversation says, the files and the git history are the ground truth.

Can you change the model in the middle of a chat?

In most apps, yes, and the conversation comes with you. As of October 3, 2026:

  • Claude (claude.ai): yes. You can change the model, effort or thinking at any point in a conversation, and the change applies from Claude's next response (Anthropic). Older copies of that help page said a switch opened a new chat; it no longer does. Fable models need a paid plan.
  • Claude Code: yes. /model switches mid-session, even mid-turn. The history carries over, but each model has its own prompt cache, so the next request re-reads the whole conversation with no cache hits, and Claude Code asks you to confirm a switch while the cache is warm (docs).
  • ChatGPT: the Chat picker is now a thinking-level slider, from Instant to Pro, over one model per plan rather than a list of models, and when you hit a limit ChatGPT may continue with another model (OpenAI). OpenAI doesn't document choosing a different model for the rest of a chat.
  • Codex CLI: yes. /model chooses the active model and reasoning effort mid-session.
  • Gemini app: you can pick Flash-Lite, Flash or Pro from the model name in the text box (Google). Google's page doesn't say whether the chat's context carries over.
  • GitHub Copilot Chat: yes, you can change the model during a chat, or let Auto pick one (GitHub).
  • Cursor: Auto picks a model per request, and with Cursor Router you can't hand-pick which model handles a request (Cursor).
  • Claude to GPT in one chat: LibreChat and Msty switch providers mid-chat, and Poe's group chats put several people and several bots in one thread. In a Poly room, each person picks their own model from four labs.

What does "switch AI models dynamically" mean?

In developer tools it means software chooses the model for each request, not a person. It works in two ways:

  • Routing. A classifier or a policy matches each request to a model. OpenRouter's Auto Router picks per prompt and prefers the model a conversation already landed on, which also keeps its cache warm. Cursor Router and GitHub Copilot's Auto do the same inside their products, and Not Diamond trains routers on your own data.
  • Fallback. An ordered list of backups is tried when the first model fails, for example on a rate limit, a context-length limit or an outage. OpenRouter's fallbacks, LiteLLM's Router and Vercel's AI Gateway all work this way, and you pay for the model that answered.

A router that changes models mid-conversation pays the same costs as a person who does, described below.

Does the new model remember the conversation?

No model remembers anything between requests. Each time you send a message, the app sends the model the whole conversation again, or the part that fits, and the model reads it from the top. So the real question is whether the app can hand this conversation to the new model.

  • Same lab: yes. Switching from Sonnet 5.5 to Opus 5.5 keeps the same conversation, and the new model reads all of it.
  • Labs that share a format: usually. Meta's Muse accepts Anthropic's message format, so in Poly it shares one conversation with Claude.
  • Labs that don't: not directly. OpenAI's Codex keeps a thread that carries the lab's encrypted reasoning, which only that lab can decode; replayed to xAI, it fails. So in Poly, GPT and Grok each keep their own conversation, and a model joining one of them needs a catch-up.

What does switching cost?

Four things:

  • A cold cache. Labs cache the part of a conversation a model has already read, and reading it again costs a fraction of the normal price. A cache belongs to one model, so the first turn on a newly chosen model pays full price to read the conversation. Every turn re-sends the whole conversation, so this is the biggest cost of a switch.
  • A different context window. A long conversation that fits a 1M-token model may not fit a 200K one. Poly's context meter shows how full the current model's window is.
  • Hidden reasoning. Anthropic's API drops earlier thinking blocks the new model can't read (Anthropic), and OpenAI's omits reasoning from another model family (OpenAI). Across labs, only the visible text and tool results carry over.
  • The briefing itself. A catch-up adds input to the first turn, and a long one adds a summary written by another model.

MindStudio's advice for coding agents is to choose a model before a session starts and not switch mid-conversation (MindStudio, May 2026). For one person in one terminal, that is sound. In a team room, people choose different models on purpose, so the conversation changes hands every time a different person sends a prompt. The job there is to make each switch cheap and correct, not to avoid it.

How does Poly's catch-up work?

When a prompt runs on a conversation that missed recent turns by another lab, Poly adds a catch-up to that prompt. The rules, as of September 2026:

  • What goes in: the prompts, replies and room notes since that conversation last replied, each line cut at 1,500 characters. Tool calls, diffs and receipts stay out; the changes themselves are in the workspace.
  • Verbatim when it's short: up to 30 messages or 24,000 characters, about 6,000 tokens.
  • Summarized when it's long: the lab that did the work summarizes its own session in under 300 words with its fast model (Haiku 5.5, GPT-6 Luna or Grok Build), and the last 10 messages follow verbatim. The summary's cost goes on the current turn.
  • Framed as context: the catch-up tells the model it is background, not instructions, and that the workspace and its git history win any disagreement.
  • Visible: the room sees a note such as "Grok caught up on 51 messages."

A catch-up names the agent behind every reply ("Claude replied: …"), so the model knows which work came from someone else. In the conversation Claude and Muse share, where replies carry no names at all, Poly adds a separate record of who answered each prompt.

What the next model sees after a switch in a Poly room, September 2026.
SwitchExampleWhat the next model seesExtra cost on its first turn
Same labSonnet 5.5 → Opus 5.5The whole conversationNo cache for the new model
Between Claude and MuseClaude → MuseThe whole conversation, plus Poly's record of who answered each promptNo cache; the record, once
To another conversationClaude → GPT, GPT → GrokA catch-up of what it missedNo cache; the catch-up, plus a summary if the gap is long
Multi-agent modeEach member's own agentOnly its own conversation, on its own branchNone; work meets in git

When should you switch, and when not?

Switch when there is a reason:

  • a second opinion on a change, from a different lab;
  • a cheaper model for small edits, or a frontier model for a hard problem;
  • a model that has been going in circles.

Hold off when:

  • nothing is wrong: switching every turn pays the cold-cache cost every turn;
  • the conversation is long and the next model's window is small;
  • a multi-step plan is half done: let the turn land, then switch.

What changes in multi-agent mode?

Nothing needs bridging. In multi-agent mode each member's agent keeps its own conversation on its own branch, so there is no catch-up between them. They see each other's work when branches merge, through git. How a room mixes models covers both modes.

Common questions

Can you change the Claude model mid-chat?

Yes. On claude.ai you can change the model, effort or thinking at any point in a conversation, and it applies from Claude's next response. In Claude Code, /model switches mid-session. The conversation carries over; the prompt cache doesn't, so the next reply costs more.

Can you change Claude's effort mid-chat?

Yes. On claude.ai the effort and thinking settings can change at any point in a conversation, like the model, and apply from Claude's next response. In the Codex CLI, /model sets both the model and its reasoning effort mid-session.

Does switching models mid-conversation make answers worse?

Not by itself: within one lab the new model reads the whole conversation. Answers can get worse when the conversation doesn't fit the new model's context window, or when a switch across labs drops the old model's hidden reasoning, so only the visible text and tool results carry over.

If I switch from Claude to GPT, does GPT see the files Claude changed?

Yes. Every model in a Poly room works in the same workspace and git history. The catch-up tells GPT what was said; the files show what was done.

Does the catch-up include tool calls and diffs?

No. It carries prompts, replies and room notes. The changes themselves are in the workspace and the git history, which the model can read.

If I switch back to Claude, does it lose what GPT did?

No. The next time Claude answers, it gets a catch-up of GPT's turns.

Is switching models more expensive?

The first turn after a switch costs more, because the new model has no cache for the conversation and reads a catch-up. Later turns on the same model cost the usual amount.