A familiar math problem arrives in a new disguise. The numbers are different; the wording has changed. A powerful language model can solve it—but often by retracing the whole route from the beginning. Researchers have built a way to save not just the answer, but a reusable version of the reasoning that produced it.
The method, called agentic reasoning caching, starts with a model solving a problem and producing a written reasoning trace. A second model turns that trace into small, inspectable computer programs. Later, when a related question comes along, those programs can extract the new values, carry out the reusable steps and return an answer—without calling the original, more expensive model.
The key is separating two jobs that language models often perform together: figuring out the method, and applying it. If the task is to count the divisors of a number, for instance, the general method is to find its prime factors and use their exponents to work out the count. Changing the number changes the arithmetic, not necessarily the underlying method. The researchers’ cache tries to preserve that distinction.
Building one takes more than copying a response into storage. The system analyzes the original question and its solution, identifies which pieces of the question can vary, and breaks the reasoning into smaller operations. It then writes those operations as “semantic functions”—programs whose inputs and purposes are described in ordinary language rather than only by fixed variable names. One function might extract a temperature from a sentence; another might convert units; a third might perform a calculation.
Those functions can call one another, and their work is recorded as a readable explanation. The result is closer to a small, task-specific toolkit than a saved transcript. If a new question is phrased differently, the cache searches for a matching task, extracts the relevant information and runs the corresponding functions. If it cannot find a sufficiently close match—or encounters a problem—it can pass the question to the larger model instead.
A worked example in the paper uses an ideal-gas problem. The original question gives amounts, volume and temperature in text. The cache separates those inputs, detects the temperature unit, converts it when needed and performs the pressure calculation. Some arithmetic runs as ordinary code; a smaller language model helps with language-dependent chores such as recognizing or extracting values. Each step can leave a narration trail, so a person can inspect how the result was reached.
The researchers tested their approach on eight benchmark sets covering competition math, graduate-level science questions, grade-school arithmetic and broader academic knowledge. They report that the cache matched or exceeded its source model’s accuracy on seven of the eight. On the 2025 American Invitational Mathematics Examination set, for example, the cache scored 93.3%, compared with 83.3% for the source model. On grade-school math, the cache scored 98.0%, just below the source model’s 98.5%.
They also tested whether the caches could handle changes beyond the exact questions used to build them. They tried new phrasings, changed problem parameters, and combinations of both. Across those tests, the cache’s reported success rate was at least 90.8%. That lowest figure came from combined changes to the AIME 2026 problems. In other words, the system did not need the question to arrive word-for-word as before—but it was not infallible.
The cost story has two sides. Constructing a cache took between 12.1 and 83.7 times the cost of a single original model response, depending on the benchmark. But once built, invoking it cost 16.3 to 291.1 times less per problem than using the source model. The researchers estimate that caches for AIME problems could recover their construction cost after about 13 related uses; for GSM8K grade-school math, about 90 uses.
That tradeoff makes the idea most appealing when the same kind of reasoning is repeated many times with new details: a familiar procedure, a changing payload. The cache is not just a shortcut to an answer. Because its workings are stored as code, a reviewer can inspect and correct them, and deterministic calculations can avoid some slips a model might make in its final arithmetic. In the AIME tests, the authors suggest this helped the cache outperform the source model on some cases where the model’s reasoning was sound but its final answer was not.
There are important boundaries to the result. The study tested benchmark problems and carefully generated variants, not a deployed system handling the unpredictable mix of requests found in everyday use. Robustness tests were run on original questions the cache already answered correctly, and the cache-building phase itself is costly. Turning a written solution into code also does not guarantee that the code captures the right logic. The researchers describe real-world use as a goal, not an established outcome.
Still, the shift in perspective is striking. Instead of treating every model response as a one-time performance, this approach asks whether some reasoning can be extracted, checked and reused as a tool. The first answer may take substantial work to produce. The useful discovery is that the next one might not have to start from scratch.
