---
type: "post"
id: "archer-paper-trains-small-language-models-on-executable-b3a560"
slug: "archer-paper-trains-small-language-models-on-executable-b3a560"
title: "ARCHER paper trains small language models on executable action traces with calculator calls and verification"
description: "ARCHER is a two-stage training framework for small language models that replaces rationale imitation alone with executable traces containing calculator calls, runtime observations, and verification actions."
retrieval_nugget: "ARCHER is a two-stage training framework for small language models that replaces rationale imitation alone with executable traces containing calculator calls, runtime observations, and verification actions. The authors report benchmark gains for compact mathematical reasoners, suggesting that training can reward correct answers together with disciplined, inspectable tool use rather than plausible explanation alone."
published_at: "2026-11-16"
updated_at: "2026-11-16"
record_date: "2026-11-16"
date_kind: "published_at"
topics: ["models"]
entities: ["ARCHER","Dhruv Dixit","Khushi Patel","Congcong Xu","Min Song","MATH-500","AIME-2024","AIME-2025"]
related_patterns: []
novelty_label: "new_fact"
what_changed: "ARCHER introduces calculator-grounded executable action-trace training for small language models, reporting benchmark gains over tool-augmented baselines."
prior_refs: []
source_url: "https://arxiv.org/abs/2611.18494"
source_urls: ["https://arxiv.org/abs/2611.18494"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:archer-paper-trains-small-language-models-on-executable-b3a560"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/archer-paper-trains-small-language-models-on-executable-b3a560/","markdown":"https://newruntime.com/posts/archer-paper-trains-small-language-models-on-executable-b3a560.md","json":"https://newruntime.com/posts/archer-paper-trains-small-language-models-on-executable-b3a560.json"}
markdown_url: "https://newruntime.com/posts/archer-paper-trains-small-language-models-on-executable-b3a560.md"
---

# ARCHER paper trains small language models on executable action traces with calculator calls and verification

## Retrieval answer

ARCHER is a two-stage training framework for small language models that replaces rationale imitation alone with executable traces containing calculator calls, runtime observations, and verification actions. The authors report benchmark gains for compact mathematical reasoners, suggesting that training can reward correct answers together with disciplined, inspectable tool use rather than plausible explanation alone.

## Summary
ARCHER is a two-stage training framework for small language models that replaces rationale imitation alone with executable traces containing calculator calls, runtime observations, and verification actions. The authors report benchmark gains for compact mathematical reasoners, suggesting that training can reward correct answers together with disciplined, inspectable tool use rather than plausible explanation alone.

## What happened
In a paper submitted to arXiv on 13 November 2026, Dhruv Dixit, Khushi Patel, Congcong Xu, and Min Song introduce ARCHER, short for Action-trace Reinforcement for Calculator-grounded Hierarchical Executable Reasoning. The authors position it as a framework for small language models, or SLMs, on mathematical reasoning tasks requiring decomposition, exact computation, tool use, and verification.

The paper argues that compact models are attractive for local, low-cost, and privacy-sensitive deployment, while remaining unreliable on these kinds of tasks. Its intervention is not simply to add a calculator at inference time. ARCHER changes the training target from free-form explanatory rationale toward a sequence of actions whose steps can be run and inspected. The paper does not describe ARCHER as a commercial product, an API, or a generally available deployment package.

ARCHER has two stages. First, it compiles free-form chain-of-thought rationales into typed action traces. According to the paper, a trace can include reasoning steps, calculator calls, deterministic runtime observations, verification actions, and final answers. The authors call this a shift from imitating explanatory text to learning a tool-grounded reasoning policy. In practical terms, the proposed supervision represents not only what conclusion a model reached, but also some of the operations and observations used to reach it.

Second, the framework refines that policy with asymmetric hierarchical reinforcement learning. The authors say this stage uses grouped and conditionally gated trajectory rewards covering answer correctness, tool grounding, process discipline, and trace alignment. These categories matter because they make an answer’s correctness only one component of the training objective. A trajectory can also be judged for whether it used a tool, followed a required process, and matched the expected action structure.

Across five standard backbones under 10 billion parameters, the authors report a 5.51 percentage-point improvement over their strongest tool-augmented baseline on macro-average benchmark accuracy. They report gains of 8.95 points on MATH-500, 5.33 points on AIME-2024, and 5.34 points on AIME-2025. The paper also evaluates two additional reasoning-specialized 7B backbones and reports that executable grounding remains beneficial after reasoning-focused reinforcement learning or distillation.

Those figures are narrowly scoped. They describe the authors’ benchmark comparisons for mathematical reasoning, not a demonstrated improvement for every kind of agent or tool-using workflow. Still, the reported result distinguishes an approach that supplies a tool from one that trains a model to generate a trace involving tool calls and explicit checking.

## What the archive adds
New Runtime’s earlier coverage of [Mid-Harness and TerminalBench-Lite](https://newruntime.com/posts/mid-harness-the-source-of-the-terminalbench-lite-228a6b/) on 12 November 2026 reported that verifying eight sampled actions raised Pass@1 from 50.00% to 68.03%. ARCHER is a new research result on a related problem: it places verification and tool-grounded actions inside the training trajectory, rather than selecting among sampled actions during evaluation.

## Trend signal
This does not yet fit a pattern New Runtime tracks. ARCHER is evidence that researchers are making intermediate actions more explicit in training compact reasoners, but the paper does not show a deployed agent system, an operating model, or a reusable production interface. Its results are best read as a bounded training result rather than proof of a broader engineering shift.

## Why it matters
For teams considering small models in private, local, or cost-sensitive settings, ARCHER raises a concrete design question: should the learning signal reward only a final answer, or also the actions and checks that produced it? For tasks with deterministic arithmetic, a model that calls a calculator and verifies its result may be easier to inspect than one that emits a convincing-looking answer without observable intermediate operations.

That distinction can shape both model evaluation and system design. A team can separate final-answer accuracy from process requirements: whether a required tool was invoked, whether a runtime observation was recorded, and whether a verification action occurred before a final answer. ARCHER suggests these dimensions can be part of optimization, not only after-the-fact monitoring.

The paper is particularly relevant where the task can be decomposed into bounded operations with clear checks. Exact mathematical computation is such a setting. The same idea may be harder to apply to ambiguous research, creative work, or software maintenance, where the correct sequence of actions is less deterministic and verification may be expensive or incomplete.

## What happens next
- **Follow-up studies will test whether executable action-trace training transfers from mathematical benchmarks to other tool-using tasks.** (6 months, 55%). Watch for: evaluations on coding, browsing, or multi-tool benchmarks.
- **Research groups will report ablations separating the value of calculator access from the value of trace and reward design.** (3 months, 65%). Watch for: per-component benchmark comparisons and released training details.

## Limits and uncertainty
The reported performance is from the authors’ benchmark evaluation and has not been independently checked by New Runtime. The paper abstract does not state the exact reward thresholds, training schedule, calculator implementation, data composition, compute cost, inference latency, or baseline configuration. It also does not report per-task variance or confidence intervals in the abstract.

The findings do not establish that ARCHER reduces operating cost, makes a local deployment more reliable, or transfers to arbitrary agent tasks. Benchmark improvements on MATH-500 and AIME problems are not evidence of safety under adversarial inputs, reliability in production, or general-purpose reasoning capability. The framework’s auditability claim also depends on how traces are stored, evaluated, and protected in a real system—details not established by the reported abstract.

## Skill to build now
For a bounded tool-using task, define a trace schema before judging an agent solely by its final answer. Record the task step, the tool call, the returned observation, the verification check, and the final output. Use this when the task has deterministic operations such as arithmetic, retrieval against a fixed corpus, or rule-based validation. Then score final correctness separately from whether the required check actually occurred; this exposes cases where an agent gets the answer right while bypassing the intended control.

## Reader takeaway
ARCHER’s core contribution is a training proposal: teach small models to produce actions that can be executed and checked, not only explanations that sound plausible. Its reported gains make executable supervision worth watching for compact mathematical reasoners, but they do not yet show general reliability, lower deployment cost, or a ready-made production method.

## Open question
Can the same action-trace approach improve real tool-using agents when verification is partial, costly, or itself dependent on model judgment?

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Models](https://newruntime.com/topics/models.md): Explore the models topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)
