A Task changes hands all the time on a team running several coding agents. A Sonnet worker writes the change and an Opus reviewer checks it. A Claude Code Agent stalls and the Task moves to a Codex Agent. Claude Sonnet 5.5, released September 28, puts in writing something that was always partly true: the model’s reasoning does not go with the work. Anthropic’s what’s new in Sonnet 5.5 page says every thinking block “records which model produced it”, and no other model reads Sonnet 5.5’s blocks.
The trouble is how quietly it happens. When a request carries a block the model can’t read, the API drops it before the model sees it. The request succeeds, the dropped blocks aren’t billed, and the only trace is an input_transformations entry, which appears only if you sent the thinking-binding-controls-2026-08-01 beta header. The reviewer Agent gets the diff without the why, nothing errors, and the review looks better informed than it is.
TL;DR
For agent handoff context between models, one rule covers it: the only context that survives a handoff is what someone wrote down on the Task. Thinking blocks are bound to the model that produced them, to the exact conversation, and for Sonnet 5.5 to the account. Make every Agent end its run with a handoff comment: decisions and their reasons, assumptions, what was tried and failed, open questions, files touched, checks run. If you build your own harness, keep history append-only.
A thinking block is bound three ways
A thinking block is the reasoning a model produced for one turn, returned with a signature the API checks before a later request can use it. The preserved thinking docs describe three bindings, and each matches a handoff your team already makes.
Model. Sonnet 5.5 reads blocks from Sonnet 5, Opus 4.8, Haiku 4.5 and earlier models, but not from Opus 5, Opus 5.5, Fable or Mythos. Direction matters: per Anthropic’s notes on switching models mid-conversation, a conversation that moves from Sonnet 5 onto Sonnet 5.5 keeps its reasoning, and one that moves from Sonnet 5.5 to any other model runs the later turns without it. That includes Anthropic’s own server-side fallback, which retries some declined Sonnet 5.5 requests on Sonnet 5.
Conversation. A block is usable only when it follows the exact system prompt, tools and messages it was produced from. The docs’ FAQ spells out the consequence: reasoning can’t be carried into a different conversation, so start the new one from a summary of the task state (the goal, decisions made, files and results so far, the next step). When a Task moves to a different Agent, the Runtime starts a new session, which is a new conversation even on the same model. It is the same reason a fresh session of one tool starts cold, covered in maintaining context across AI sessions.
Account. Sonnet 5.5’s blocks work only in the account that produced them or one linked to it. Anthropic’s launch post names one place this shows up: switching accounts mid-session in Claude Code.
Put together: between Agents, reasoning never traveled. Sonnet 5.5 made that part of the API contract.
Three handoffs that quietly drop reasoning
| Handoff | What carries over | What’s lost | What tells you |
|---|---|---|---|
| Sonnet 5.5 worker Agent to Opus 5.5 reviewer Agent | The diff, the repository, the Task description and comments | Sonnet 5.5’s thinking. No other model reads it, and the review run is a new session anyway | Nothing across Agents. Inside one API conversation, a model_binding_mismatch entry with the beta header |
| Claude Code Agent to Codex Agent | The diff, the branch, the Task record, the repo’s shared rules file | All of Claude’s thinking and the Claude Code session state. Codex starts its own conversation | Nothing |
| Same model, different account (an account switch mid-session in Claude Code, or a saved session replayed with another account’s credentials) | The visible transcript: messages, tool calls, results | Every Sonnet 5.5 thinking block produced under the first account | An organization_binding_mismatch entry with the beta header, on the Claude API and Google Cloud. Otherwise nothing |
The last column is the problem. All three handoffs succeed, and the receiving Agent answers confidently from less than the previous one knew. A reviewer on another model can approve a change the worker had doubts about, because the doubts lived in thinking it never saw.
We wrote earlier that switching between coding agents “preserves the code and drops the reasoning.” That now holds at the API level too, which matters for teams that run Claude Code and Codex on one codebase and for routing rules that escalate. If hard Tasks go from a Sonnet 5.5 worker to Opus 5.5, as in Sonnet 5.5 or Opus 5.5: which agent gets the task, every escalation is a handoff from the first row.
What a handoff note must carry when the reasoning can’t
A coding agent handoff note has one job: put the reasoning that matters in writing, where the next worker can read it. The fields below extend Anthropic’s summary shape with two things thinking blocks held and diffs never show: why a path was chosen, and which paths were already ruled out. Paste it into the instructions of every Agent that can pass a Task on:
Before you finish, post one comment on the Task that starts with "Handoff".
Write it for a reader who has this Task and the diff, and nothing else.
Decisions: each choice you made and the reason for it, one line each
Assumptions: what you took as true without verifying it
Tried, failed: approaches you ruled out and why, so nobody retries them
Open questions: what a person or the next Agent has to decide
Files touched: paths changed, and which ones are unfinished
Checks run: exact commands and their results; name any check you skipped
Next step: the one action you would take next
Three details keep it honest.
Ask for decisions, not the reasoning itself. Sonnet 5.5 is the first Sonnet with safety classifiers against reasoning extraction, and its reasoning_extraction refusal category covers requests to reproduce internal reasoning in the response text. “Paste your thinking into the comment” is that request. “List each decision and its reason” is an ordinary report.
“Tried, failed” saves the most time. A dead end is invisible in a diff. Without the note, the next Agent is free to walk into the same one.
Checks mean commands and output. “Tests pass” is a claim. The command that ran, with its counts, is evidence a reviewer can rerun.
The decision pair: skip the note when one Agent takes a Task from assignment to review in a single run and the person accepting it reads the diff anyway. Require it the moment a Task changes Assignee, changes model, or goes to a reviewer Agent. The coding agent handoff templates cover the seams between a person and an Agent; this note covers the seam between two Agents.
If you build your own harness, editing history is now an error
Most readers can skip this. The preserved thinking docs say nothing changes if Claude Code, claude.ai, Claude Managed Agents or the Claude Agent SDK builds your requests. It matters when your own code calls the Messages API.
For accounts created on or after August 31, 2026, 00:00 UTC, on the Claude API, Amazon Bedrock and Google Cloud, replaying a Sonnet 5.5 thinking block after a change to anything before it (the system prompt, the tools, an earlier message) returns a 400. Older accounts see the check only when a request opts in, which sets a trap: your own key passes, and a user running your tool on a newer account’s key hits the 400 first. The fix: keep the conversation append-only.
- Freeze the system prompt and tools at session start. Change instructions by appending a mid-conversation system message, which Sonnet 5.5 supports and Sonnet 5 does not.
- Send each assistant turn back exactly as returned, empty thinking blocks included.
- Compact through the API, not by rewriting old turns. Compact on demand (beta
compact-2026-09-04) returns a signed summary block you send in place of the messages it covers. The docs’ recommended simple compaction sends one summary message plus the next instruction, so no old thinking is replayed.
{ "role": "system", "content": "Review found a race in the retry path. Do not change the public API." }
With the beta header, prefix_mismatch_behavior: "drop_block" drops failing blocks instead of erroring. The docs are clear that it hides the edit rather than fixing it.
Notice the shape of Anthropic’s recommended compaction. When reasoning can’t be replayed, Anthropic’s answer is a written summary: a handoff note by another name.
Where the handoff lives in Sharkly
The Task is the shared record, and the handoff belongs on it because nothing else outlives the session. A Task holds the Conversation (comment-backed dialogue), the Activity timeline of comments and changes, and the Executions history of every run. Agent text meant for the team is saved as a comment linked to the run. When an Agent needs an answer, its question returns to the Task as a comment, the Task shows waiting for human reply, and the question reaches that person’s Inbox.
Reassignment is where this pays off. Change the Assignee from a Sonnet 5.5 Agent to an Opus 5.5 reviewer, or to a Codex Agent, and the next run starts from the Task, not from a transcript. Sharkly’s docs list what a task-backed run can include: the title and description, recent comments and the comment that triggered the run, the Agent’s instructions, and its repositories. The handoff comment is on that list. The previous Agent’s thinking is not, and on a model change the API would drop it anyway.
Two habits follow. The docs say to write team-visible conclusions in comments or the Task description, so anything settled in a side chat with an Agent goes there before the Task moves. And because a run pulls in recent comments, fold decisions that must hold for the whole Task into the description.
This is where provider neutrality earns its keep. The Agent follows the Runtime’s default model, so the handoff rule lives in the Agent’s instructions and works the same whether the next Runtime is Claude Code on Sonnet 5.5 or Codex on something else. Setup is in how to run Claude Sonnet 5.5 agents in Sharkly. Agents research, execute, test, and report. People set direction, grant authority, and accept the result from the same written record the next Agent reads, which is what human ownership of agent work depends on.
Preserved thinking started with Fable 5.1 and now covers Opus 5.5 and Sonnet 5.5. Build handoffs that never depend on reasoning traveling, and the next model change won’t break them. If you’re already running several agents, Sharkly gives you one place to manage their tasks and results.
