My team runs small models to cut cost — can I actually teach them to reason, or do they just imitate big-model rationales?
5 min read
You can teach them to reason, but the outcome depends less on how much rationale text you feed them than on what you make them produce during training. That distinction is the entire contribution of a paper that landed on arXiv on 13 November 2026: ARCHER, "From Rationale Imitation to Executable Reasoning in Small Language Models," by Dhruv Dixit, Khushi Patel, Congcong Xu, and Min Song. It is a first submission with no revision history yet, so treat the numbers as the authors' reported results rather than independently verified ones — but the argument it makes should change how your team thinks about distillation.
The setup your team probably already knows: small models are cheap, local, and privacy-friendly, but they fall apart on the math that requires decomposing a problem, doing exact arithmetic, using a tool, and checking the result. The usual fix is to collect free-form rationales from a stronger model and fine-tune the small one on them. The paper's claim is that this teaches the model to write about reasoning, not to do it. The fluent prose is the supervision target, so the fluent prose is what gets learned.
ARCHER keeps the same starting rationales but changes what the model is trained to output. Stage one compiles each free-form rationale into a typed action trace: reasoning steps, explicit calculator calls, the deterministic results those calls return, verification actions, and the final answer. The model is no longer scored on whether its explanation reads like a good explanation; it is trained on a trajectory in which every arithmetic claim is backed by a tool call whose output the trajectory then consumes. Stage two refines that policy with what the paper calls asymmetric hierarchical reinforcement learning, using grouped and conditionally gated rewards covering answer correctness, tool grounding, process discipline, and trace alignment.
Here is what the shift looks like, as an illustration rather than a result from the paper. On a question like "a tank holds 3 liters and a pipe adds 0.75 liters per minute; after 14 minutes, how much more water is needed to reach 15 liters," the imitated rationale is a sentence: the pipe adds 10.5, so the tank has 13.5, leaving 1.5. The compiled trace instead records 0.75 times 14 as a calculator call, takes the returned 10.5 as a runtime observation, adds 3 to it, subtracts the result from 15, and closes with a verification step before emitting 1.5. The prose version can sound perfect while being arithmetically wrong; the trace version cannot, because each number either came from a real call or it does not appear.
Source: ARCHER: From Rationale Imitation to Executable Reasoning in Small Language Models
The reported results, across five sub-10B backbones, are a 5.51-percentage-point gain over the strongest tool-augmented baseline in macro-average accuracy, with 8.95 points on MATH-500 and 5.33 and 5.34 on AIME-2024 and AIME-2025. Two additional reasoning-specialized 7B backbones show the benefit persists even after the model has already had reasoning-focused RL or distillation — a useful answer if your instinct is that you already fine-tuned on chain-of-thought data.
Two limits to hold onto. First, the scope is mathematical reasoning; the paper does not establish that executable traces transfer to code generation or open-ended planning, so do not extrapolate past the benchmarks. Second, it is a four-day-old preprint, and the backbone names and baseline construction live in the full text rather than the abstract.
Source: ARCHER: From Rationale Imitation to Executable Reasoning in Small Language Models
If you are weighing this against the obvious alternative — keep the small model and route the hard requests to a frontier model — a way of thinking we suggest, and not a finding of the paper, is to find the cost crossover. Count the fraction of your traffic that the small model currently gets wrong or that you would route up, multiply by the frontier model's per-request cost, and you have your routing bill. Then estimate the one-off cost of the training path: collecting rationales on your task, compiling them into executable traces, running the reinforcement-learning stage, and building an eval set. Training wins when hard-request volume is high enough that the routing bill exceeds that one-off, and when your own eval set — not the paper's math benchmarks — shows the trained small model actually closes the gap on your distribution. Below the crossover, routing is cheaper and simpler; above it, the trained model is the cheaper system at every future volume. Note that this is a different decision from serving-time routing or from bolting scaffolding around a frozen model: here the change goes into the small model's own weights.
Source: ARCHER: From Rationale Imitation to Executable Reasoning in Small Language Models
The paper also hands you a verification habit worth adopting. Take the headline number, 5.51. Open arxiv.org/abs/2611.18494 and confirm the abstract states it as a macro-average gain over the strongest tool-augmented baseline — it does. Note the version and date: first submission, 13 November 2026. Then read past the abstract to where the backbones and baselines are defined before you quote the figure anywhere. That is a two-minute check that separates "the authors report X" from "X is true."
That habit — open the source and check the supporting passage — is exactly what SentX SI's model card tells its own users to do in its known-limits section, and it extends naturally to the problem in your question. When a small model returns an answer, the check is not whether the explanation is fluent; it is whether the trajectory contains real tool calls and runtime observations you could re-run yourself. A fluent rationale is text to be read; an executable trace is a computation to be verified. If your team trains the small model the way ARCHER describes, you get both: a model whose answers you can audit, at a fraction of the cost of sending every hard request to the frontier.
Source: Victoria AI Model Card
Sources
- ARCHER: From Rationale Imitation to Executable Reasoning in Small Language Models — arXiv
Supported claims and limits
- Paper is arXiv:2611.18494, submitted 13 Nov 2026, by Dixit, Patel, Xu, Song; v1 only, no revision history
- Small language models are attractive for local, low-cost, and privacy-sensitive deployment but remain unreliable on mathematical reasoning requiring decomposition, exact computation, tool use, and verification
- ARCHER is a two-stage framework: stage one compiles free-form chain-of-thought rationales into typed action traces (reasoning steps, calculator calls, deterministic runtime observations, verification actions, final answers), shifting supervision from imitating explanatory text to a tool-grounded reasoning policy; stage two refines via asymmetric hierarchical RL with grouped and conditionally gated trajectory rewards for answer correctness, tool grounding, process discipline, trace alignment
- Across five standard sub-10B backbones, improves over strongest tool-augmented baseline by 5.51 pp macro-average, 8.95 MATH-500, 5.33 AIME-2024, 5.34 AIME-2025; self-reported v1 figures
- Two additional reasoning-specialized 7B backbones show benefit persists after reasoning-focused RL or distillation; backbones unnamed in abstract
- Victoria AI Model Card — SentX SI
Supported claims and limits
- Known-limits section instructs users to open cited sources and check the supporting passage
- Model card is a first-party product disclosure, not an independent certification