Research · November 17, 2026

Beyond arithmetic: a tool-use world and a general action interface

In a tool-use world, Cortex trained on whole tasks of 1 to 4 tool calls solved 0% of 50-call tasks. Demos cut from inside longer tasks, plus tools given as schemas, brought it to 71.8% when handed the right facts (two runs: 98.5% and 45%), and 7.2% with its own learned reader.

Mendrika Ramarlina · November 17, 2026 · 9 min read

In a second domain, every Cortex arm we first trained scored 0% on tool-use tasks needing 32 or 50 calls, while the best arms scored 97–100% on tasks of 1 to 4 calls. The cause was a shortcut in the short demonstrations, not capacity.

Cortex, for this post: a frozen 2B-parameter open language model encodes text, a small recurrent latent policy does the reasoning over a memory of facts and results, and exact tools do the exact work. The policy keeps a goal stack: the goal it is working on sits on top, and when a precondition fails it pushes a subgoal (get the key) above it. Until now the tool was a calculator. The previous part ended on the arithmetic system's reading limits. This one moves to a world with no numbers in it.

This is research at Saina, not a product, on small models and synthetic tasks.

The tool-use world

The world has rooms, doors, keys and objects. A task is a goal like "the package is in the office". Each move, pickup, door opening or drop is a tool call that can fail. Preconditions matter: you cannot pick up an object in another room, or open a locked door without its key.

Training used tasks of 1 to 4 calls only. Evaluation went to 8, 16, 32 and 50 calls. "Oracle" below means the policy sees exactly the facts the expert's rule reads, which isolates the policy from retrieval. The "learned reader" is the trained part that picks those facts from memory on its own.

Zero past the training range

With oracle facts, nothing reached 32 or 50 calls. At 16 calls the best was 5–6%.

Plain actions stayed almost always right on long tasks. What failed were the decisions to set a subgoal because a precondition did not hold:

decision (arithmetic-initialized arm, oracle facts) 1–4 calls long tasks
object is elsewhere: first go to its room 100% 22.1%
door is locked: first get the key or reach the door 98.5% 61.8%
object is here: pick it up 100% 98.2%

The training tasks explain it. In a 1–4-call task, a blocked route can only be finished if the key is already at hand. So "blocked means the key is right here" always held in training, and the policy learned that instead of checking where the key is. At 8 to 50 calls keys are elsewhere and the rule breaks.

Episodes then failed by looping on the same failed call: 120 to 145 repeats per 50-call episode.

We had predicted that local decisions would extrapolate. They are local, but what they were trained on was not representative.

Arithmetic weights: mostly scale

We also compared starting from scratch, from the arithmetic system's weights, from those weights frozen, and from those weights with every tensor's entries shuffled (same scale, no learned structure).

With oracle facts, initializing from arithmetic beat scratch at every training size: +15.4 points in range and +28.8 at 8 calls at the middle size. But the shuffled control matched it in range at the two larger sizes, and at 8 calls it was as good or better (−1.2 and −10.0 for real minus shuffled). Only at the smallest size did real weights clearly beat shuffled ones, by 12 points in range. Frozen transfer was 12 to 30 points below scratch in range.

Our read, from two runs per arm: at the two larger sizes most of the "transfer" is weight scale, not structure. The goal stack did matter here: without it (one run), decision accuracy at 50 calls was 16–19%, against 60–63% with it.

Demonstrations from inside longer tasks

The fix we tested kept every demonstration at 4 calls or fewer, but cut half of them as windows from inside expert episodes of 5 to 18 calls, starting from the real memory and goal stack at that point.

The "go get it first" decisions recovered, from 17–22% to 87–99.8% and from 38–62% to 86–98.5%. Up to 16 calls, success went from about 0 to 92–97%.

At 32 and 50 calls it stayed low, and the reason was ours. Memory entries carried an absolute "calls since written" bucket, and the windows almost never filled the high buckets that long tasks fill all the time. Clamping those buckets to the trained range at evaluation only:

scratch arm 16 calls 32 calls 50 calls
short tasks only, oracle facts 0% 0% 0%
with windows, as trained, oracle facts 97.2% 36.8% 1.8%
with windows, age clamped at evaluation, oracle facts 97.0% 91.8% 84.5%
with windows, age clamped at evaluation, learned reader 65.8% 16.8% 1.0%

With the clamp the two runs reached 94% and 90% at 32 calls and 87% and 82% at 50, and decision accuracy at 50 calls was 99.6–99.7%. These numbers depend on a correction applied only at evaluation, which we found by looking at these long-task results. It is one value set by the trained range, not tuned, but it makes the clamped rows a diagnostic, not a trained result. Both lessons repeat arithmetic: training states must cover what long tasks produce, and inputs must not depend on absolute length.

The reader row is the other finding: the learned reader picks exactly the right facts about 90% of the time at 50 calls, over about 100 decisions per episode.

Can a language model write the tool calls?

In the world, every action was a whole sentence scored against the others, which cannot extend to new tools. So we went back to arithmetic, where the first frozen milestone (the arithmetic system frozen at the end of part 5, with a fixed action head) is a clean reference, and changed one component at a time.

First test: feed the milestone's decision features through a learned projection into the frozen language model and have it write JSON tool calls. It read the decision almost perfectly: right tool 99.85%, right sentence to work on next 99.9%, valid JSON 99.99%. It could not write numbers. Calculator calls were right 0.7% of the time and answers 1.7%. It also took 26.9 ms per decision against 1.1 ms.

The latent state carries which memory slot to use, not that slot's exact value in a form the decoder can read out. Arguments should be references to memory, not values a model writes.

Tools as input, arguments as pointers

So the next head took each tool as input (a frozen vector of its name and description) and chose arguments by pointing into memory. The executor resolves the pointer to the exact value.

Calls went to 99.7% right and answers to 100%, at 1.4 ms per decision. Per decision it was within a point of the fixed head (99.3% vs 99.9%). Per problem it was not:

Tool arguments as pointers into memory A tool call whose two arguments point at memory slots holding exact values, and the executor returns an exact result. With pointer arguments 99.7 percent of calculator calls are right. When a language model writes the numbers, 0.7 percent are right. Memory slot 1 slot 2 slot 3 slot 4 slot 5 exact values Tool call calculatorargument 1argument 2 exact result arguments point into memory: 99.7% of calls right a language model writes the numbers: 0.7%
Arguments are references to memory slots. The executor resolves each one to the exact value.
fixed head dynamic head
standard worded problems, solved 98.5% 88.5%
problems needing 50 calculator calls, solved 89.5% 59.0%
choosing the next subgoal right 99.95% 98.9%

The gap is in choosing the next subgoal, and it compounds over long problems. Decoding the tool and its arguments jointly recovered 3 to 4.5 points but did not close the gap.

Then tools it had never seen, given as new names and free-text descriptions. On the standard set, 18% solved. A nearest-neighbour check of the frozen encodings showed why: a new tool's vector was closest to a training tool with the same operation in 3 to 5 of 8 cases, against 2 of 8 by chance. Neighbours followed surface words. increase_by landed next to other tools containing "by".

We chose to translate tools into canonical schemas before encoding: for arithmetic, a plain statement of what the tool returns plus canonical argument roles, written by hand as a stand-in for an automatic translator. With that, unseen tools reached 88.3% on the standard set, the same as known tools. That mainly shows the pipeline works when translation is right; arithmetic has no tools with new meanings to test more.

Memory slots without numbers

The milestone's memory slots were a digit encoder plus fixed classes, so nothing but numbers could live there. We replaced them with an exact payload plus a small adapter (about 0.5M parameters, the only part trained) over encodings of sentences about the value: "The value is 59.", where it came from, the tool that produced it.

Paired against the same head on the old slots: 91.5% vs 88.5% on the standard set, 60.0% vs 59.0% on 50-call problems, 99.5% of decisions right. The frozen fixed head, given the new slots without retraining, still got 98.9% of decisions. Memory no longer depends on arithmetic.

The world through the tool interface

Back in the world, two arms from scratch, two runs each. One kept whole action sentences. The other used tool schemas (effects and preconditions in the policy's own condition language) with a pointer at a room, item or door slot as the argument. Both got recency features meant to replace the clamp: age capped at the trained range, plus a flag for "written after the current goal was set".

oracle facts 1–4 calls 16 calls 32 calls 50 calls (per run)
action sentences 100% 94.4% 86.4% 62.5% (43.5 / 81.5)
tool schemas 99.6% 96.4% 87.6% 71.8% (98.5 / 45)
earlier windows arm, age clamped at evaluation only 99.8% 97.0% 91.8% 84.5% (87 / 82)

The bottom row is the earlier diagnostic, with its correction applied only at evaluation; the two new arms needed no such correction.

Tool schemas cost nothing on these runs: −0.4 points in range, ahead at 50 calls. The clearer result was a probe whose first task is to put a key down, which training never asks. For the sentence arm "Put down the brass key." is untrained; the drop tool just points at any item slot. Schemas solved 75% of that probe, sentences 8%.

The recency features reached 50 calls in some runs, not reliably: each arm had one run near or above 80% and one near 45%. On average neither arm matched the evaluation-only clamp at 50 calls. With the learned reader, 50-call success was 7–16.5%.

Next: tools with new effects

The next stage is unseen tools with genuinely new effects: renamed tools, a door forced with a crowbar, a world with no tool for opening locked doors. It is designed and not run.

Some of the numbers above are thin. Two runs per arm cannot say which arm is better at 50 calls, and one schema run stopped early. The language-model decoder, the dynamic head and the generic slots are single runs. The recency change bundled three changes, and we cannot say which one matters. The dynamic head's subgoal gap on arithmetic is unexplained. Three fixes are untried, and a longer run is in progress with no results yet.

In the world, the learned reader is the main limit. New object and room names still fail there (0–5% success), as new wording did in arithmetic. And shuffled weights matched real ones for transfer, so we have no evidence yet that any learned weight encodes reasoning rather than the structure of one task family.

The overview lists what the series as a whole has not shown.