What two weeks of latent reasoning experiments taught us
Trained only on problems needing 1 to 4 calculator calls, Cortex now solves 85.5 to 89.5% of problems needing 50 calls with no search, in the wording it was trained on. Reading new wording is now the limit.
Trained only on problems that need 1 to 4 calculator calls, Cortex now solves 85.5 to 89.5% of problems that need 50 calls, with no search, across two seeds. That holds for the sentence templates it was trained on. Earlier in the same two weeks, policies trained the same way solved 0 to 2% of problems that needed 8.
Cortex is the system these notes are about. A frozen 2B-parameter open language model encodes text. A small recurrent latent policy does the reasoning over a memory of facts and results. Exact tools, a calculator first, do exact computation.
This is research at Saina, not a product. The tasks are synthetic arithmetic word problems, a small tool-use world and grade-school math (GSM8K). Every claim in this series is about this system on these tasks.
On the arithmetic problems, depth and memory size looked like the limits for most of the two weeks, and no longer are. What limits the system now is reading: new wording, tools it has not seen, and, in the tool world, picking the right facts out of memory.
The pattern behind the results
The same failure showed up in both domains we tried: near perfect inside the training range, collapse past it. Each fix that worked changed what the policy receives, not its size. More layers, wider tables and longer training did not move it.
What we take from the two weeks:
- Length is a data and interface problem here, not a capacity one. Missing long dependency chains in training, an absolute "how long ago" feature on memory entries, and a shortcut learned from short demonstrations each caused a collapse past the training range.
- What is stored is separate from how it is used. Past the training range, probes read the needed information out of the policy's state at 79 to 88% while its next-action accuracy was 0 to 6%. The decision rule failed, not the state.
- Exact values need an exact channel. A latent path trained to carry an exact state bit by bit left answers at chance. A language model writing numeric tool arguments from Cortex's state got 0.7% of calls right. Memory now holds exact values, and actions point at them.
- Once depth and position were removed, interference was what remained. The main confuser was the model's own computed results (67% of wrong picks), not similar-looking facts.
- Short-problem skills carry over when the problem is cut into bounded pieces. Given an oracle decomposition into self-contained subproblems, frozen policies trained on short problems solved 95 to 99% of problems needing 20 calls.
- Reading is the current frontier. The system now fails on new wording, new tools and GSM8K operand choice. For tools, the encodings group descriptions by surface words, not by what the tool does. On GSM8K, operand errors follow cue words such as "half" and "dozen".
Method rules that came out of the failures: run causal controls (latents removed, latents shuffled) before reading any depth result. Change one mechanism per experiment. Stop a run when long-problem scores are flat for three evaluations, and change the representation instead of training longer. Match the previous frozen milestone before moving to the next component. Do not train a component a rule can replace.
The parts
Thinking in vectors instead of tokens: what failed first. The frozen model already does the arithmetic when it thinks in text: its multiple-choice answers go from 55/100 to 100/100 with thinking on. Replacing those thinking tokens with continuous states mostly failed. A decoder trained alongside the latents routed around them (shuffled latents scored the same as real ones), and one latent step through the frozen model added about 8 points while staying about 60 points below thinking in text.
Near perfect in range, zero past it: the long-horizon collapse. With a calculator doing the arithmetic, the latent policy scored 82.7% on problems of 1 to 4 steps and 8.5% at 8 or more. The stored state was intact and the needed information was decodable; the decision rule did not carry over to longer executions. A parameter-matched text baseline went further (27.5% at 8+ steps) at about 10 times the latency. Reranking calls with a value model or beam search scored 25.6 to 33.5 points below plain greedy decoding.
Removing depth and position as failure modes. An explicit goal stack made decisions 97 to 100% correct at any stack depth, as long as the goal sat in the first 50 tokens of the input. Encoding each sentence on its own removed the position effect: with the goals given, decision accuracy on problems needing 20 calls went from 29.5% to 94.5%.
The confuser was the model's own results: selective memory. Handing the policy exactly the right memory entries lifted 50-call success from 14.8% to 91.2%. A learned reader, trained only on short problems, that returns a set of entries for the current goal got 85.5 to 89.5% with no oracle help, and that system became the first frozen milestone.
It learned the template, not the relationships. Reworded versions of the same problems dropped the milestone to 0.25% at 50 calls even with perfect retrieval. An adapter trained on three wording families brought those families most of the way back but left new wording at 0% at 50 calls. On GSM8K, an expression-tree policy answers 62.2% of 452 evaluation problems (one seed; about 3 points of that come from near-copies of training problems), with operand choice as the main error.
Beyond arithmetic: a tool-use world and a general action interface. In a second domain, every arm hit 0% on 32- and 50-call tasks while the best scored 97 to 100% in range. The cause was a shortcut: in short demonstrations the key is always at hand, so the policy learned to act as if it were. Training on short windows cut from longer tasks reached 84.5% at 50 calls with the right facts supplied, but only with a memory-age correction applied at evaluation, and 1% with the learned reader. Pointer arguments into memory replaced generated numbers. Held-out arithmetic tools described in free text reached 18%, and 88.3% once translated by hand into canonical schemas; these were new names for known operations, not new capabilities.
What we have not shown
- Held-out wording and domains. The three-family adapter does not transfer. We do not know yet whether broader wording would, or whether some sentences cannot be decided without reading their neighbours.
- Held-out tools. No encoding we tested groups tools by what they do. Whether schemas written ahead of time (typed arguments, preconditions and effects) make tools with new effects work is the next test, and has not run.
- Memory reading in the tool world. With the learned reader in the loop, 50-call success is 7 to 16.5%.
- The merged pipeline. With the goal stack as planner, problems needing 20 calls reach 82 to 83%, close to the 83 to 85% with oracle subgoals. The planner is not the limit; handing each subproblem the right facts is.
- GSM8K problems of 5 or more steps stay at 9% or below. Problems that long were rare in training.
- Seed variance. With the right facts supplied, 50-call success in the tool world was 98.5% for one seed and 45% for the other with the same design. The weaker run stopped early and may be undertrained. Two seeds cannot say which is typical.
- Whether any learned weight is about reasoning. In the tool world, at the larger training budgets, transferring the arithmetic weights helped about as much as transferring the same weights shuffled, so most of that transfer was weight scale, not structure.
Several results above rest on one seed per arm. Each part says which.