I took the reasoning one Gemini model produced, replayed it to a different model, and watched the second model's thinking tokens fall by 60%. Google's much-vaguer promise that "the backend manages compatibility" turns out to be real, which is inconvenient, because the other two vendors' rules would have had me throw that reasoning away.
You run a conversation. One turn is answered by a big model, the next goes to a cheaper one, because you route on difficulty, or because the first was rate limited, or because it was retired out from under you. The first model produced reasoning that cost you output tokens. What do you do with it?
Every vendor selling reasoning models has had to answer that, and the answers do not line up. Worse, all three failure modes are quiet: nothing 500s, nothing warns, and the difference shows up only in a token count.
The three rules agree on the verb and disagree on everything else
All three now tell you to keep sending the reasoning. They disagree completely about when the receiving model can actually use it, and that is the part that costs money.
OpenAI scopes reuse to a model family: "Persisted reasoning can be reused only within the same model family. For example, gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna can reuse each other's reasoning, but reasoning does not carry between the GPT-5.6 and GPT-5.5 families." Cross that boundary and the API "omits incompatible reasoning from the model's context, even when reasoning.context is all_turns". all_turns is the setting whose whole purpose is to keep everything, and it is honoured only up to the family line.
Anthropic scopes it by age instead: "Keep passing thinking blocks back unchanged when you switch models." Whether the target can read them depends on which direction you moved, because "a thinking block is readable only by the model that produced it or a newer one, and the API ignores or drops the blocks the target model can't read." Upgrade mid-conversation and the reasoning survives; downgrade and it does not. Anthropic is also the only one of the three to say what the failure costs: "The API drops a block the current model can't read, without an error and without billing it."
Google scopes it not at all. "You MUST always resend all thought blocks exactly as they were received from the model," and on switching specifically: "When switching models within a session, you should still resend the previous model's thought blocks. The backend manages compatibility."
Family, direction, and a shrug. Google makes the strongest claim and gives the least account of the mechanism, which is why it is the one worth testing rather than believing.
Getting the experiment wrong twice is what made the result trustworthy
Turn one asks gemini-3.8-flash a two-step train-schedule question. Turn two asks for an intermediate value from that work: recoverable from the reasoning if it carries over, and otherwise only by working it out again.
My first version of this measured nothing, twice over, and both errors flattered the conclusion I expected.
The first was a leak. Turn one was free to show its working, so the value turn two asks for sat in the visible answer as well as in the thought block. Every condition could simply read it off. Nothing was ever re-derived, and what I had measured was the cost of re-reading. Turn one now ends "Reply with only the final clock time and nothing else", and the probe aborts before spending a token if the visible answer still contains the number:
leak check: {"visibleAnswerChars":8,
"firstTrainArrivalInVisibleAnswer":false,
"firstTrainArrivalInThoughtBlock":true}
The second was a confound. Stripping the thought block also strips its signature, so a kept-against-stripped comparison cannot tell the reasoning text from the signature that points at it. Three payloads fix that: full is text and signature, textOnly is the same text with the signature removed, stripped is neither. Only the middle one isolates the signature.
I am spending three paragraphs on this because the corrected design reversed the finding. The earlier, broken version supported a much better headline, which is exactly why it deserved the scrutiny.
The signature crosses the model boundary and does real work
Three runs per condition, because thinking token counts move between identical requests. Every one of the eighteen runs returned the correct answer.
prompt thinking (3 runs) mean
A-full 745 49, 46, 55 50.0
A-textOnly 420 167, 52, 61 93.3
A-stripped 88 67, 52, 54 57.7
B-full 745 82, 65, 66 71.0
B-textOnly 420 183, 177, 176 178.7
B-stripped 88 202, 277, 179 219.3
The pair that matters is B-full against B-textOnly. Same receiving model, same thought text, same everything, and the signature is the only difference between them. Thinking drops from 178.7 to 71.0, a 60% reduction, and the ranges do not come close to touching: 82, 65, 66 against 183, 177, 176.
So a thought signature produced by gemini-3.8-flash measurably does work inside gemini-3.6-flash. Not a smaller prompt, not a rounding artifact. The receiving model reasons less because it was handed the first model's reasoning, and Google's one-line claim survives contact with a test.
Note the direction. I replayed reasoning from a newer model into an older one, which is precisely the direction Anthropic documents as the one that fails. On Gemini it worked.
A corrupted signature is a 400, on both models
There is a deflationary reading of all this: the field is inert across models, and something else explains the gap. Replacing the signature with a base64 string of the wrong bytes rules it out.
A-corruptedSignature gemini-3.8-flash HTTP 400
B-corruptedSignature gemini-3.6-flash HTTP 400
INVALID_ARGUMENT: Corrupted thought signature.
Both models parse and validate. The receiving model is not holding the field at arm's length; it opens it, and rejects it when the bytes are wrong. That is the same 400 on a model that did not write the signature, which is the strongest single line of evidence here that the mechanism is genuinely cross-model.
Working is not the same as worth it
The savings are real and they are also nearly cancelled by what they cost. On the receiving model, carrying the text and signature adds 657 prompt tokens to save 148.3 thinking tokens. Priced at Gemini Flash list rates of $0.75 per million input and $3.75 per million output including thinking, that is 493 against 556 in the same units: about 13% ahead. Isolating the signature alone is a better trade, 325 extra prompt tokens for 107.7 saved thinking tokens, roughly 1.66 to one.
On the producing model the trade collapses, because it barely thinks about the follow-up either way: 50.0 thinking tokens with its own signature against 57.7 without, on overlapping ranges. There is almost nothing there to save, and you would pay 657 prompt tokens to save it.
The general shape is a ratio, not a rule. Keeping reasoning pays when the thinking it saves is expensive relative to the tokens needed to carry it, and this task sits close to the line. A long chain of reasoning that is costly to rebuild moves you well past it. A cheap follow-up like this one does not.
Every run got the right answer, so this measures cost and not quality
All eighteen runs answered correctly, which means nothing here speaks to whether losing reasoning makes an answer worse. That needs a scored evaluation on harder questions, not one arithmetic problem, and if your workload looks like that then the numbers above are a floor rather than a bill.
The scope is narrow on purpose: one vendor, one model pair one minor version apart, one task, n=3, free tier, v1beta generateContent. A-textOnly is visibly noisy at 167, 52, 61 and no claim rests on it. B-textOnly against B-stripped overlaps, so I am not claiming the thought text helps on its own. The OpenAI and Anthropic rows are documentation, not measurement: I hold no key for either, and their behaviour may be kinder or harsher than their docs, in the same way Gemini kept accepting parameters it had already deprecated.
The probe is at docs/news-research/cross-model-reasoning-probe.mjs and all 22 runs, including the two 400s and the response headers, are archived beside it. The seven strings quoted from the three vendor pages above are re-checked against the live pages on the morning this publishes, and a failure there stops the release instead of shipping a stale quote.
Go and look at what your fallback path does with the reasoning
If you switch models inside a conversation on Gemini, keep the thought blocks. That is Google's documented advice, it is the opposite of what I expected to conclude, and on this evidence it is right: the signature survives the switch, the receiving model uses it, and the trade is modestly positive on the receiving side.
The rule that generalises is narrower than any vendor's wording. Reasoning is portable exactly as far as the vendor scopes it, and the boundary is different for each of them: a family on OpenAI, a direction on Anthropic, apparently nothing on Gemini. None of the three raises an error when you cross it, so nothing in your logs will tell you that a fallback quietly started paying to re-derive work you had already bought.
So go and find the code path that swaps models on a rate limit, and check what it does with the reasoning today. On Gemini, stripping the blocks costs you a mechanism that measurably works. On OpenAI's documentation, crossing a family line silently discards it. Either way you are being billed for the answer twice, and the only place it shows up is a token count nobody is reading.