Reasoning Became a Session

• Reasoning used to travel light
• The hand-off was the product
• Readable is not the same as movable
• Why quiet failures matter more than hard errors
• Score continuity, not just capability

§Reasoning used to travel light

For two years agent builders treated intermediate reasoning as luggage. Tokens came out of one call, went into a log, hopped into another model, survived a history trim. The scratchpad looked like text. Text moves.

That bargain just failed a quiet stress test. Across a dense release week, thinking blocks started sticking to the model that wrote them and to the exact conversation prefix that preceded them. Switch models mid-run and the earlier plan drops. Edit an earlier turn, the system prompt, or the tool list, and every later thinking block is invalidated. The final answer can still look polished. The continuity you thought you bought is gone.

§The hand-off was the product

Most production agent stacks are not single-model purity plays. They are routers. A cheap model starts the exploration. A stronger model takes over when the task gets ambiguous, expensive, or irreversible. The efficient pattern was to forward partial reasoning so the expensive model did not restart from zero.

That pattern depended on an unstated assumption: that a thinking block was portable state, not a lease. Under the new binding rules, a mid-task escalation either rejects the replayed reasoning, silently drops it, or forces a cold restart. Cost efficiency vanishes without a loud crash. Answer quality drifts in ways that look like ordinary model noise. The engineer debugging it six weeks later has no reason to suspect last year’s routing trick.

History editing fails the same way. Agents rewrite earlier tool results, swap retrieved documents, or accept a user correction halfway through a long run. Frameworks that reused downstream thinking now either fail hard or keep serving stale plans attached to a conversation that has already moved. Both look like model mistakes. Both are infrastructure bugs.

§Readable is not the same as movable

This is not the opaque-scratchpad story. Opaque recurrence shrinks how much thinking ever becomes text. Binding shrinks where that text is allowed to live after it exists. You can still get a legible plan from a single model on an append-only history and still lose the architecture that treated those plans as reusable parts.

It is also not a dual-door access story. Permission envelopes decide which trajectories a checkpoint is allowed to finish. Binding decides whether the intermediate work product survives a swap, a fallback, or a repair. Same weights under two doors is a policy product. Session-bound thinking is a continuity product. Operators need both on the sheet.

§Why quiet failures matter more than hard errors

Hard errors are merciful. A rejected request wakes someone. Silent drops are the real risk. A router that discards incompatible thinking and continues will still return text. A framework that keeps invalidated blocks will still return text. The customer sees a confident answer. Your bill sees a second full reasoning pass you did not budget. Your audit log shows a plan that no longer matches the history that produced the side effects.

Testing misses this for a structural reason. Single-turn smoke tests never cross a model boundary mid-task. They never edit history after thinking has already accrued. The failure mode lives exactly where agent teams under-test: long, multi-model, repairable runs.

§Score continuity, not just capability

The industry still sells intelligence as scores, speed, and access tiers. This week’s mechanics add a continuity axis that procurement should already price: can intermediate reasoning survive the operations your agents actually perform?

Ask blunt questions. Where does thinking cross a model boundary in your stack? What happens after a history edit? Are drops reported, or silent? Do staging accounts and production accounts enforce the same binding rules? If you cannot answer, you are buying a demoworthy agent with an unpriced continuity debt.

Reasoning that only works inside one model, on one frozen prefix, is still useful. It is not the same product as portable thinking. Treat the hand-off as a first-class failure mode. Design routers to choose once near the start. Treat every history edit as a fork that forces fresh planning. And stop assuming last year’s luggage still travels.