Your Coding Agent Needs a Handoff Contract, Not Just a Bigger Model

A familiar operating pattern is emerging around coding agents: start the task with a cheaper model, let it run until it gets stuck, then escalate to a stronger model with the full transcript attached. It feels sensible. Why pay premium rates for the easy setup work? Why throw away context that has already been paid for?

A new paper, “The Handoff Tax: Continuing Non-Native Trajectories in LLM Agents”, gives teams a reason to slow down before turning that pattern into production policy. The authors study long-running coding-agent tasks that span many model calls, tool uses, and code edits. They vary handoff direction, timing, and how much trajectory information the receiving model inherits. Their headline finding is uncomfortable: in the studied settings, full-trajectory escalation from a lower-capability model to a higher-capability model recovers less than half of the quality gap while adding a substantial cost premium.

That does not mean escalation is useless. It means the transfer object matters.

Most agent stacks treat the conversation transcript as the natural handoff format. The transcript is convenient because it is already there. But a transcript is not the same thing as task state. It mixes correct discoveries, dead ends, stale assumptions, tool noise, partial plans, failed edits, and the previous model’s private sense of momentum. A stronger model inheriting all of that is not simply “more informed.” It may also be anchored to a path it did not choose and cannot fully trust.

For enterprise teams, the practical answer is not to abandon model routing. It is to design a handoff contract.

A handoff contract is a compact, structured transfer packet that says what the next agent needs to know in order to proceed safely. For a coding agent, that packet should start with the current repository state: branch, changed files, tests run, test results, and the exact command used to produce them. It should include the original task in business language, the accepted constraints, and the definition of done. It should separate verified facts from hypotheses. It should list failed approaches and why they failed, but without forcing the receiver to replay every confused step. It should identify open risks: migrations not run, edge cases not covered, suspected race conditions, flaky tests, permission boundaries, or security-sensitive paths.

That sounds less glamorous than “multi-agent orchestration,” but it is exactly where the leverage is. Anthropic’s practical guidance on building effective agents argues for starting with the simplest solution and adding complexity only when needed, because agentic systems trade latency and cost for performance. A handoff contract follows the same principle. Do not pass a larger context just because the window allows it. Pass the smallest state representation that preserves the next decision.

The paper’s most interesting implication is that escalation and downshift should not use the same interface. According to the abstract, reducing the lower-capability model’s trajectory information improved escalation quality, while removing the higher-capability model’s trajectory information reduced downshift quality. That makes intuitive operational sense. When escalating, the stronger model may need a cleaner view: the task, the repo, the evidence, and the remaining problem, not every local detour. When downshifting, the cheaper model may benefit from the stronger model’s reasoning trail because the hard pathfinding has already happened.

So the routing policy should be asymmetric.

Escalation should look like a clean-room takeover. Preserve the codebase state, artifacts, failing commands, and verified evidence. Summarize the previous attempt with suspicion. Ask the stronger model to re-plan from the current state rather than continue the weaker model’s narrative. If the previous agent says “the bug is probably in auth,” the handoff should show why: stack trace, failing assertion, changed file, reproduction steps. If it cannot show why, that statement belongs in “unverified hypotheses,” not “facts.”

Downshift should look more like delegated execution. Preserve the strong model’s chosen plan, assumptions, invariants, and stopping conditions. Give the cheaper model the next concrete slice: implement this adapter, update this test, run this command, report only these outcomes. In other words, do not ask a cheaper model to rediscover the architecture. Ask it to execute bounded work under a plan that has already been shaped.

This also changes how teams should evaluate coding agents. A simple pass-rate benchmark can miss the cost of bad transfers. The better question is: after a handoff, can the receiving agent identify the true current state, avoid repeating failed work, preserve safety constraints, and make forward progress at a justifiable cost? Anthropic’s write-up on its multi-agent research system makes a related production point: complex workflows need discrete evaluation checkpoints where specific state changes should have occurred, along with careful context-management strategies for long-horizon work. Handoffs deserve their own checkpoints.

A useful internal eval might include three scenarios. First, a weak-to-strong escalation after a partially wrong implementation. Does the stronger model correct course, or polish the wrong approach? Second, a strong-to-cheap downshift after a correct design. Does the cheaper model preserve the plan, or reopen settled decisions? Third, a compressed handoff where the transcript is replaced by structured state. Does quality improve, degrade, or simply become cheaper? These are operational questions, not leaderboard trivia.

There is also a governance angle. The NIST AI Risk Management Framework frames trustworthy AI as something incorporated into design, development, use, and evaluation. Model-routing policy is part of that design. If a production agent can change models mid-task, someone should be able to answer when that is allowed, what evidence triggers it, what context crosses the boundary, and how the receiving agent’s work is audited.

A practical handoff contract can be small. Start with seven fields:

1. Task contract: the user goal, constraints, and definition of done. 2. Repo state: branch, changed files, relevant diffs, dependency changes, and commands run. 3. Evidence ledger: tests, logs, traces, source links, and which claims they support. 4. Failed paths: approaches already tried, with concrete failure evidence. 5. Open hypotheses: plausible but unverified explanations. 6. Safety constraints: files not to touch, secrets not to read, migrations not to run, external systems not to mutate. 7. Next action: the smallest useful step for the receiving agent.

The important discipline is separation. Facts are not hypotheses. Failing commands are not vibes. A previous model’s confidence is not evidence. A transcript is not a contract.

The “handoff tax” is a reminder that agent performance is not only a property of the model. It is a property of the model, the harness, the memory policy, the evaluation loop, and the shape of the work passed between them. Bigger models can help. But if the transfer layer is muddy, escalation can become an expensive way to inherit confusion.

The next generation of coding-agent infrastructure will not just ask which model should run. It will ask what the next model should receive.