Where reasoning shows up: math, code, tools, plans

Mathematics: where steps are unforgiving

Maths is the classic proving ground because the steps are crisp and a single slip ruins the answer. Math problem solving is where chain of thought first showed dramatic gains: written-out working lets the model carry intermediate quantities instead of computing everything in one leap. Modern reasoning models handle competition-level problems by reasoning at length and double-checking their algebra.

p(r_{1:n},\,a \mid q) \;=\; \left(\prod_{t=1}^{n} p\!\left(r_t \mid r_{<t},\,q\right)\right) p\!\left(a \mid r_{1:n},\,q\right)

Chain of thought factors an answer into a product of conditional reasoning steps — so one wrong step can break the whole chain.

But pure text reasoning still fumbles long arithmetic — a model can reason perfectly about how to multiply two big numbers yet get a digit wrong doing it. That limitation is the bridge to tools, below.

Code: reasoning you can run

Code generation is among the most economically important capabilities, and it is reasoning in disguise: writing a correct program means tracking state, respecting constraints, and composing pieces into a working whole. Code has a rare virtue — it is checkable. You can run it and see if the tests pass, which turns vague 'is this right?' into a hard signal.

User: What is 4173 * 2891?

Assistant (reasoning): Long multiplication by hand is error-prone.
I'll compute it instead of guessing.

  >>> 4173 * 2891
  12064143

Answer: 12,064,143

Reasoning recognizes its own weakness at arithmetic and offloads the calculation to a tool rather than guessing digits.

Reaching for tools

The deepest shift in recent capability is that reasoning need not happen in the model's head alone. Tool-augmented reasoning interleaves thinking with tool use: the model decides it needs a fact, a calculation, or a web lookup, calls out for it, reads the result, and continues reasoning with that result in hand. A code interpreter is the workhorse here — the model writes a snippet, runs it, and trusts the exact output instead of its own shaky mental arithmetic.

This is why the math and code sections matter together: the smartest move a reasoning model can make is often to recognize the limit of its own head and delegate. Knowing when to reach for a tool is itself a reasoning skill.

Planning over many steps

Stitch tool calls together over time and you get multi-step planning: decomposing a goal into ordered sub-tasks, doing each, and adapting when a step fails. Push the horizon out — many tool calls, many minutes, a goal that needs dozens of dependent actions — and it becomes long-horizon reasoning, the hardest regime, where small per-step error rates compound into drift. This is the engine inside an LLM agent.

Decompose the goal into an ordered list of concrete sub-tasks.
Execute one sub-task, calling a tool when the model's own head is unreliable.
Read the result and check it against what the plan expected.
Revise the remaining plan if reality diverged, then continue to the next step.