Three clocks behind one answer

Imagine watching only the final hand of a clock. It reaches twelve. That observation does not tell you whether a spring stored energy over hours, gears transmitted motion over seconds or a person moved the hand directly. Machine outputs have the same underdetermination. A final answer compresses away the process that produced it.

A useful system description therefore separates at least three state channels. Let θ denote reusable model or policy state, w_t temporary working state during an episode, and F_t a frontier of alternatives that remain available for exploration. A system transition can then be sketched as:

The symbols are intentionally modest. They do not claim that every model exposes a neat scratchpad or that all learning occurs in weights. They ask three diagnostic questions. Did θ or another reusable policy state change? Did w_t+1 depend on an intermediate result in w_t? Did F_t contain alternatives that were evaluated, expanded, pruned or selected?

Learning: a change that can be reused

In classical supervised learning, an error signal changes parameters so that future inputs are mapped differently. Back-propagation is a canonical mechanism for such change.1 Reinforcement learning changes a policy or value estimate through consequences. Programme synthesis may alter executable rules. A system may also acquire a persistent skill through a library, adapter or verified memory. These are different implementations, but each creates a disposition available beyond the immediate trace.

This persistence criterion is stronger than “performance rose after feedback”. A tool response can improve the next step without teaching the model. A retrieved example can guide the current request without changing the next fresh request. A cache can make repeated work faster while preserving the same decision policy. Persistent effect is evidence for learning only when the affected state is identified. Otherwise the word hides whether the model, scaffold, memory or environment changed.

Reasoning: dependent transformation within an attempt

Reasoning is the least settled term. Here it has an operational meaning rather than a claim about consciousness or human-like thought. A trace is reasoning-like when intermediate state carries inferential work forward. The result of one operation constrains a later operation: calculate the difference, infer which rule applies, test a consequence, revise the conclusion. The dependency matters more than whether the steps are printed in English.

Chain-of-thought prompting can elicit useful intermediate text and improve performance on some tasks.6 Yet displayed explanations are not guaranteed to reveal the actual causal route. Experiments have found systematic cases where chain-of-thought explanations omit or misrepresent influential cues.10 A rationale is an observation channel, not a privileged transcript of hidden computation. Reasoning attribution should therefore use interventions on intermediate state, tool dependencies and counterfactual traces where possible.

Search: alternatives under a selection rule

Search begins when the system represents more than one live continuation for the same decision and has a method for deciding what to expand, retain or return. Breadth-first search uses frontier order. A* uses accumulated cost plus a heuristic. Monte Carlo tree search combines sampling, value estimates and visit statistics. Language-model systems may sample candidate solutions and use self-consistency, a verifier or an external test to choose among them.7

Branching alone is not enough. Producing five answers and showing all five is candidate generation. Calling the first answer “best” without an evaluation rule is ungrounded preference. Search requires an explicit relation between alternatives and selection. The evaluator may be imperfect, learned or deterministic, but it must exert causal pressure on which path survives.

Why the words collapse into one another

The confusion is not merely careless speech. The same system can be described at several legitimate levels. At the behavioural level, it “learns” if examples improve later performance. At the algorithmic level, an optimiser searches a parameter landscape. At the task level, a solver reasons through constraints. At the implementation level, every one of these activities is a sequence of state transformations. Move high enough and the categories merge; move low enough and every multiplication looks alike.

Neither extreme helps with diagnosis. Saying that gradient descent is a kind of search is mathematically defensible, but it does not tell an operator whether the deployed model’s weights changed during a customer case. Saying that all reasoning is computation is also true at a broad functional level, but it does not reveal whether the system maintained a chain of dependent propositions or merely emitted a stored association. The useful grain is the level at which an intervention changes the outcome.

Consider the sentence “the system learnt to reason by searching”. It can be perfectly precise when expanded. During training, selected trajectories changed reusable parameters. During inference, those parameters produced dependent intermediate states. At difficult decision points, a frontier explored alternatives. Learning, reasoning and search describe different phases and state channels in one design. The sentence becomes misleading only when success in one phase is credited to another without evidence.

This distinction also prevents two symmetric errors. The first is anthropomorphic inflation: a fluent explanation is treated as proof that the model performed the same deliberation a person would report. The second is mechanistic deflation: any capability learned during training is dismissed as “mere pattern matching”, even when the deployed computation uses structured intermediate state and tools. Output fluency proves neither view. Trace interventions are needed in both directions.

A final source of collapse is product naming. “Reasoning model” may denote a model trained with verifiable rewards, a model allowed more inference tokens, a wrapper that samples many candidates, or some combination. The label can be useful shorthand, but it is not an architecture manifest. A technical claim should expand it into model version, update mechanism, context policy, candidate budget, evaluator and persistence boundary.

flowchart TD
  A["The route planner that<br/>“learnt” nothing"] --> B["Three clocks behind one answer"]
  B --> C["Interventions, not labels"]
  C --> D["When the mechanisms compose"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#5B5CF6,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

Interventions, not labels

A useful classification should survive changes in terminology. The same architecture may be marketed as a reasoning model, an agent, a planner or an adaptive system. Instead of adjudicating names, intervene on the trace. Three tests do most of the work: reset persistence, perturb dependency and expose alternatives.

Three counterfactual questions

Each intervention asks what would happen if one causal feature changed while the rest stayed as stable as possible. The persistence counterfactual asks whether the improvement remains when temporary state is removed. The dependency counterfactual asks whether changing an intermediate result changes downstream conclusions. The branch counterfactual asks whether removing, adding or rescoring an alternative changes which path is selected.

These are stronger than reading logs after the fact. A log may show that a model printed several ideas, yet none influenced the answer. It may show a memory write that is never retrieved. It may show a rationale created after an action was already selected. Counterfactual intervention tests causal use rather than mere co-occurrence.

The controls matter. For a reset test, use equivalent unseen cases rather than repeating an item the system can cache. For a dependency test, perturb a value that should change the conclusion and one that should not. For a branch test, preserve the evaluator while varying candidate quality, then preserve the candidates while varying the evaluator. A classification earns confidence by surviving matched controls.

The reset intervention

First, hold the task distribution and model version fixed. Clear temporary context and episode state. Repeat equivalent cases. If a behavioural improvement survives, locate the persistent carrier. It may be weights, a programme, a policy table, an adapter or an external skill record. If the improvement disappears, the previous behaviour was context-bound or episode-bound.

The reset must be typed. Clearing the chat while retaining a user profile is not a full reset. Reloading a container while keeping a vector memory is not a full reset. Reusing a warmed cache can preserve information without learning. Record the boundary explicitly: model parameters, runtime state, retrieved evidence, external memory, tool state and environment.

Perturb the dependency chain

To test reasoning-like inference, intervene on an intermediate result while preserving the initial question. If later steps change in the way the dependency predicts, the intermediate state is causally active. If the final answer remains fixed and the explanation is rewritten around the perturbation, the displayed chain may be decorative, incomplete or downstream of another route.

This is why chain-of-thought visibility and reasoning are not identical. A model may reason through latent activations and print no rationale. It may print a rationale while relying on a shortcut. It may use tools whose outputs form the true dependency chain, while prose merely summarises them. Faithfulness studies use interventions such as truncation, corruption and early-answer prediction to examine whether the written chain affects the result.11

Expose siblings and their judge

To test search, inspect whether sibling candidates exist for the same decision point. Assign each a stable identifier. Record who generated it, what evidence it used, how it was scored, why it was expanded or pruned, and which rule selected the survivor. Tree of Thoughts made this distinction explicit by maintaining coherent alternatives, evaluating them and allowing lookahead or backtracking rather than relying only on left-to-right generation.8

The evaluator is part of the mechanism, not an accessory. If it cannot rank promising paths above plausible mistakes, more branches amplify cost and error. Research on test-time compute distinguishes at least search against a verifier from adaptive changes to the response distribution.12 Treating both as “the model thought longer” erases the variable an engineer must tune.

Common false positives

Several familiar traces look like the target mechanisms without establishing them. A long response is not necessarily reasoning. It may be repetition, stylistic expansion or a sampled continuation whose later tokens do little causal work. Multiple responses are not necessarily search. Without a goal test or evaluator that affects selection, they are only a set of candidates. A second pass is not necessarily self-correction. It may replace a correct answer with a more confident mistake when no discriminating feedback enters the loop.

That last case is not hypothetical as a research concern. Work on intrinsic self-correction has reported settings in which asking a language model to revise its reasoning without external feedback fails to improve and can degrade performance.9 The general lesson is narrower than “models cannot correct themselves”. It is that another generation pass does not create an error signal. A verifier, tool result, counterexample or independently grounded observation must make the preferred revision distinguishable.

Caching creates another false positive. A system answers a repeated question faster and more accurately after the first attempt, but the decision mechanism has not learnt anything. The response was stored. External memory is more interesting because retrieved experience can alter future behaviour across episodes. Even then, the trace should say “persistent system adaptation via memory” unless the model or reusable policy itself changed. This distinction controls rollback: delete or quarantine the memory record for one failure, restore a model checkpoint for another.

Finally, tool use is neither reasoning nor search by itself. A calculator can execute one deterministic operation. A database can retrieve one row. The trace becomes reasoning-like when later decisions depend on those results, and search-like when tools help evaluate alternatives. Components acquire their mechanism label from causal participation, not from their mere presence.

When the mechanisms compose

Separating the mechanisms does not require isolating them. Strong systems often braid them deliberately. A learned policy narrows a search space. Search discovers high-value trajectories. A reasoning process evaluates constraints within each trajectory. Successful trajectories become training data, changing the policy that guides the next search.

This composition appears clearly in AlphaZero-style systems, where reinforcement learning and tree search reinforce one another,13 and in MuZero, which combines a learned model with tree-based planning.14 Recent formal-reasoning systems also combine reinforcement learning with proof search and verified environments.15 The lesson is not that every capable system needs all three mechanisms. It is that capability attribution should follow the active component at each phase.

A minimal worked example: the five-room route

Consider a synthetic building with five rooms. From entrance A, the robot can move to B or C. B leads to a locked door. C leads to D, then exit E. Four systems receive the same map representation.

The example prevents a common category error. “The model chose C because it reasoned that B was blocked” is not warranted if the only evidence is the action. The policy might have memorised C. Conversely, a search controller can explore B and C even if its node evaluator performs no rich reasoning. The architecture must make the relevant states inspectable.

Can everything be redescribed as search?

A serious objection says the distinctions are conventional. Training searches parameter space. Deduction searches proof space. A feed-forward model selects one continuation from an enormous implicit set. On a broad mathematical description, the objection has force. Many computational processes can be represented as optimisation or state-space traversal.

But a representation can be true and still be useless for intervention. Calling back-propagation “search” does not imply that the deployed system held sibling customer decisions in a runtime frontier. Calling token generation “implicit search” does not provide candidate IDs, pruning events or an evaluator whose error can be measured. The operational category is therefore narrower: runtime search exists when alternatives are materially represented for the same decision and selection among them affects execution.

The same discipline applies to reasoning. Every neural layer transforms state, but not every transformation deserves a reasoning-like label. The label becomes useful when an intermediate artefact carries a relation, constraint or computed consequence that a later step consumes, and when perturbing that artefact predictably changes the result. This criterion does not claim that other internal computation is unintelligent. It marks the boundary at which trace-level analysis becomes possible.

Learning also admits broader and narrower readings. Behavioural psychology can call any experience-dependent improvement learning. Model engineering often reserves the term for reusable parameter or policy change. The article does not choose one as the only correct definition. It requires a qualifier that identifies the persistence channel. “In-context learning with frozen weights” and “online parameter learning that survives restart” can both be valid descriptions because they answer different questions.

The categories are deliberately asymmetric. Learning is classified mainly by persistence, reasoning-like inference by dependency, and search by alternatives plus selection. This asymmetry mirrors the different evidence each claim needs. It also permits a single event to receive several labels without contradiction.

Search can become learning

Search results are transient until some process consolidates them. Distillation is one route. A costly search procedure produces trajectories or targets; a learner updates a cheaper policy to imitate or improve upon selected behaviour. The next episode can then recover part of the search benefit without repeating the full exploration.

This conversion creates a useful diagnostic. If the expensive search is removed and performance remains improved on fresh cases, learning has absorbed some of its structure. If performance collapses, the capability still resides in runtime exploration. If only cases present in an external library improve, the system has acquired retrievable experience rather than a generalised model update.

The strongest objection: the boundaries can move

A recurrent network can perform iterative computation inside a forward pass. Fast-weight systems can update temporary parameters. Test-time training can change parameters during deployment. A language model may implement an implicit optimisation algorithm in activations. These cases challenge any rule that equates weights with learning, tokens with reasoning or an external tree with search.

The objection is correct against rigid object labels. It does not defeat state tracing. Instead of asking “Is the model a learner?”, ask which state changed at each event, what reset erases it and whether alternatives were represented. A fast weight may be temporary learning state. A latent optimiser may be reasoning-like adaptation. A test-time gradient update is still a persistent update if it survives the relevant reset. The categories belong to transitions, not to whole products.

Instrument the system you actually built

The distinction becomes operational when every claim can be reconstructed from a trace. A useful record need not expose private internal chain of thought. It can log typed events at system boundaries: model version, context version, intermediate artefact dependencies, candidate identifiers, evaluator outputs, selected action, persistent writes and reset results.

A production-shaped worked scenario

One case crosses all three clocks. The classifier’s weights are unchanged during the case, so its ranking is inference, not fresh learning. The evidence chain is temporary reasoning state. The four hypotheses and their rejection records form search. The approved case becomes learning only when a subsequent process changes a reusable model or policy. Storing the case in a retrievable library changes the wider system, but still does not change the classifier’s parameters.

Failure signatures reveal the active mechanism

A learning failure has a distinctive temporal signature. Performance improves in the training or feedback environment but not on fresh equivalent cases. It may decay after an update, interfere with an older skill or fail only after a model rollback. The right experiments compare versions, hold the inference scaffold fixed and test retention across resets. Adding more branches during one episode cannot repair a policy that never generalised.

A reasoning failure has a dependency signature. An early arithmetic error contaminates later conclusions. A tool result is ignored, or an unsupported proposition is consumed as if verified. The final answer may change when an intermediate artefact is patched, even though parameters and candidate budget remain fixed. Useful remedies include typed intermediate outputs, deterministic calculations, contradiction checks and independent readback. Retraining may help later, but it does not replace diagnosis of the broken dependency.

A search failure has a frontier signature. Promising candidates are never generated, the frontier collapses to near-duplicates, a weak evaluator ranks persuasive errors above valid paths, or pruning removes the only recoverable branch. Increasing the budget helps only some of these cases. If candidate recall is low, improve generation or representation. If ranking is poor, improve or constrain the evaluator. If all candidates share one blind spot, diversify evidence or method rather than sampling more copies.

Compound systems add cross-channel failures. A learned ranker may suppress the correct branch before deterministic checks can see it. Search may produce a successful trace that is then distilled together with spurious steps. External memory may retrieve a once-successful strategy after the environment changes. These failures cannot be assigned from the final output. They require event lineage across the braid.

The operational payoff is a smaller experiment. Instead of launching a broad “reasoning improvement” programme, a team can ask whether the failure survives reset, whether a patched intermediate fixes it and whether the correct candidate ever entered the frontier. Three bounded tests often identify the responsible state channel before expensive retraining or architectural change begins.

Misclassification leads directly to wrong remedies. Retraining the ranker will not repair an evaluator that rewards plausible but unsupported hypotheses. Increasing search depth will not repair stale evidence. Asking for a longer rationale will not create a missing persistent feedback loop. A trace that names each state channel turns a vague quality problem into a testable engineering decision.

The displayed source is generated from the same executable classifyTrace function used by the laboratory, preventing a second copy from drifting.

What to measure next

Once the trace is classified, evaluation becomes mechanism-specific. For learning, measure generalisation after reset, retention, interference, calibration and update provenance. For reasoning-like inference, perturb intermediate artefacts, test dependency faithfulness, inspect tool readbacks and measure error propagation. For search, measure frontier coverage, evaluator ranking quality, branch diversity, pruning mistakes, cost per accepted improvement and sensitivity to budget.

These measurements also change governance. A persistent update needs data approval, rollback, versioning and post-update evaluation. Temporary reasoning state needs context integrity, provenance and bounded disclosure. Search needs budget controls, verifier assurance and protection against repeated side effects. One word should not carry three control regimes.