Two Kinds of Momentum: Why Fresh Calls Change the Reasoning Process

The model that argues itself out of the right answer

A bank customer disputes a $35 overdraft fee. They say a $200 debit to a corner store called QuikMart was fraudulent, and that it’s what pushed the account negative. The file is unambiguous: the customer has shopped QuikMart roughly twenty times, always between $12 and $18. This charge is $200, at 3:14 a.m., card-not-present, from an IP that geolocates to another country.

Give that to a strong reasoning model and ask it to think step by step, in one call. It often opens with something reasonable-sounding: “The customer has an established relationship with this merchant, so this looks like a routine purchase they may have forgotten.” That sentence is now in the context window. Much of what follows is conditioned on it — “consistent with prior use,” “customers frequently forget late-night charges,” “on balance the transaction appears authorized; recommend denying the dispute.” Ask the same call to double-check its work and it will sometimes write a paragraph that mostly agrees with itself. The $200-against-a-$15-norm, the 3 a.m. timestamp, the foreign IP can go under-weighted, because the generation is busy staying consistent with the “authorized” it committed to in its first sentence.

Here is the part that matters. The model is not incapable. It generally knows that a large, off-pattern, card-not-present charge at 3 a.m. from a foreign IP is a textbook fraud signature — ask it in the abstract and it will usually tell you so at once. The capability was available the whole time. The single-pass generation is where it can get lost. Understanding why is the whole game.

Two kinds of momentum

It helps to name two forces a trained reasoning model carries into every inference, because they behave very differently.

Parametric momentum is the competence encoded in the weights by training. Much of it is ordinary learned capability; some of it, increasingly, comes from reinforcement against verifiable rewards — which is, in effect, verification that already happened, the model rewarded for reaching checkable-correct conclusions until the policy came to favor them. Where that is the source, it is verification amortized: paid once at training, reused for free at inference. Either way, it is why the model knows the fraud pattern at all. It is a good prior. You want to keep it.

Contextual momentum — the umbrella term we propose for it — is a property not of the weights but of the running generation. A language model produces tokens left to right, each conditioned on everything before it, and within a single pass it does not revise what it has already written. So once it commits to a claim, a coherence pressure can set in: the most probable continuation of “this looks authorized” is often more support for “authorized,” not a reversal. The generation starts optimizing for consistency with its own output. That is the force that can override the good prior — not because the knowledge is gone, but because the generation now has something to stay consistent with.

One force you want; one you often don’t. The difficulty is that in a single model call they are entangled: the same forward pass that supplies the competence also supplies the commitment.

Why chain-of-thought struggles to fix it

The intuitive patch is to make the model reason more — think step by step, critique yourself, reflect. Self-critique in a single context genuinely can help. But it does not create the same degree of contextual separation as an independently prompted call, and the reason is structural. Chain-of-thought is more of the same generation: when a later step critiques an earlier one, it is the same weights, in the same context, extending the same token stream that produced the conclusion. Sharing that generation history, the later step tends to inherit the earlier commitment rather than challenge it. The deliberation is real; it just runs inside the momentum it is trying to check.

This is not a fringe worry — though we should be careful not to collapse several distinct findings into a single proven cause. Work on chain-of-thought faithfulness shows that the reasoning a model narrates is often not the reasoning that produced its answer, and that the stated steps can be post-hoc rationalization (Turpin et al., 2023). Hallucination snowballing describes the error-side version: an early mistaken claim biases what follows toward justifying it, even when the model can separately recognize the claim as wrong (Zhang et al., 2023). And when a model grades its own work, self-preference bias appears — evaluators tend to favor the outputs they themselves generated (Panickssery et al., 2024). These are separate results with separate evidence. What we propose, rather than claim to have proven, is a common thread among them: when the generator is also the verifier, the check shares the generation history it is meant to audit.

As a metaphor, it can help to picture the roles collapsing together inside one call. The parametric defendant is the competence in the weights — the part that knew a $200 card-not-present charge at 3 a.m. from a foreign IP, against a $12–$18 norm, fits a fraud pattern. The contextual judge and jury is the running generation, which has already committed to “authorized” and tends to continue in ways that protect that commitment. Because it is all one forward pass, the verdict and the stake in the verdict live in the same place. The point isn’t a literal conflict of interest — it is that nothing in a single generation is scoped to evaluate the claim from outside the commitment that produced it.

Isolation reduces the commitment, not the competence

Now run the same case as an Iterative Reasoning Graph — the same underlying model, but structured.

A draft node produces the first-pass determination: “authorized, deny.” Same weights, same amortized reasoning — parametric momentum fully intact. Then an adversary node fires as a separate call. It receives only the case facts, the draft, and a single instruction: find the strongest reason this determination is wrong. It did not write the draft, so it carries no prior tokens of its own to stay consistent with and nothing invested in “authorized.” Reading the facts under that narrow charge, the knowledge that was there all along is far more likely to surface: the draft never reconciles the amount — $200 is more than ten times this customer’s norm at this merchant — and it passes over a 3 a.m., card-not-present charge from a foreign IP, which are unauthorized-transaction markers. An arbiter node weighs draft against challenge and, here, flips the determination to “unauthorized, refund,” with the anomaly on the record.

Look at what changed and what didn’t. Every node is the same model, so the parametric momentum — the competence, the fraud prior, the rules — is present at every step; nothing was thrown away. What the separate call changes is the immediate generation history: the adversary did not produce the draft, so it begins without the same token-by-token pressure to continue that claim coherently.

None of this guarantees independence. A separate verifier call can still anchor on the draft it is shown, inherit systematic biases from the underlying model, or miss the same evidence the draft missed. What we propose is narrower: this contextual separation makes genuine challenge more likely — especially when the verifier receives a narrow role, the original evidence, and an explicit standard of review. The verifier doesn’t have to be smarter than the generator; it has to be less committed to the answer.

This is the difference between a prompt and a graph, and it is not cosmetic. A prompt, however elaborate, is one generation under one momentum. A graph breaks the work into separately scoped evaluations with different evidentiary roles — draft, challenge, arbitration — each running with its own input and its own standard of review, rather than one stream grading itself.

Two timescales

It helps to separate the two momenta by the timescale they live on, rather than treat them as one force — because they are not the same thing. Training shapes the model’s standing tendencies: the competence and priors encoded in the weights, including whatever verification was amortized into them. Inference produces a case-specific trajectory that, within a single generation, can become anchored to its early commitments. The first is a property of the weights; the second, a property of one particular run. A reasoning graph preserves the first while periodically interrupting the second with fresh, scoped evaluations. It does not retrain the model, and it does not claim to make any single call unbiased; it re-enters the problem from a call that has not yet committed.

This is why scoping the work into separate calls need not be a tax on capability. You are not trading away the model’s learned competence for auditability; you keep the competence and interrupt only the commitment that can override it. There is a real cost, but it is a different one: chopping a long reasoning run into scoped calls also interrupts the model’s long-horizon search, which is why a graph is more than a pile of tiny calls — the iteration loop and the information carried between passes exist to give the reasoning room to unfold across steps while each verification stays scoped.

Does this already have a name?

Parts of it, honestly, do — and it is worth saying so. The mechanism behind parametric momentum sits in established territory: parametric knowledge, amortized inference, the generator–verifier gap, and the verification asymmetry that reinforcement-with-verifiable-rewards exploits. Contextual momentum is an umbrella we are proposing over effects that already have partial names — snowballing, chain-of-thought unfaithfulness, self-preference bias, exposure bias (Ranzato et al., 2016). We are not claiming to have discovered these phenomena, and we are not claiming they share one proven cause. The narrower, more useful claim is a single frame that separates the momentum worth keeping from the momentum worth interrupting, plus an architecture that targets one without retraining the other.

And it is testable. If the frame is right, an adversary or verifier run as a separate, scoped call should overturn more wrong determinations than the same model critiquing itself in a single pass — and the gap should widen as the verifier is given a narrower role, the original evidence, and an explicit standard of review, and should shrink as the verifier is fed more of the draft’s own generation history. If a separate call does no better than in-context self-critique under those conditions, the contextual-momentum story is wrong, and that is a result we would want to know.