Learning Reusable Agent Subroutines from Experience

The gist The central result is that induced libraries outperform the very agent that generated their traces by tens of percentage points across various subtasks, showing that recovered reasoning structure can be more reliable than the source policy itself.

How it works

Reasoning Primitive Induction is a single-pass method that mines successful ReAct traces, clusters recurrent reasoning moves, and converts the most frequent moves into a compact library of typed pseudo-tools The induced artifact is not a workflow to follow or an executable skill to call but the agent’s reusable reasoning vocabulary—a typed inventory of the recurring moves the agent reaches for when reasoning across instances of a task family These primitives are exposed as typed callable pseudo-tools, and a standard ReAct loop composes these primitives at test time. The pipeline uses two free parameters (K, m), three LLM prompts, and one fixed configuration across all benchmarks.

The Induction Pipeline

Algorithm 1 details the four stages of the induction process First, Filter retains rollouts whose final answer matches the ground-truth label. Second, Extract discards actions and observations to keep only per-step Thought strings, producing a flat corpus I of natural-language reasoning sub-steps. Third, Categorize and merge labels using one LLM call for naming and a second LLM call to cluster synonyms into 5–10 canonical categories if the unique label set exceeds ten. Finally, Top-K synthesis sorts canonical categories by frequency, samples representative thoughts from each category based on support threshold m, and prompts an LLM to emit a primitive name and docstring.

Key Findings and Comparisons

The paper demonstrates that induced libraries outperform the source agent that produced their traces by large margins, such as +44pp on RuleArena NBA (30 → 74) The mechanism is described as implicit aggregation, where synthesis sees representative thoughts from many successful rollouts and writes a corpus-level specification of each recurring move. Furthermore, induced libraries significantly surpass expert-authored decompositions on MUSR team allocation (+17pp) and NatPlan meeting planning (+15pp) The discovery-vs-design gap is not driven by the fixed-pipeline versus ReAct dispatch difference, as induced libraries exceed hand-designed primitives at matched dispatch on every cell.

Primitive Design and Deployment

A reasoning primitive is defined as a tuple p = (n, σ, d) containing a name, a typed input/output signature, and a natural-language description In this paper we instantiate primitives as pseudo-tools: typed callables registered in a ReAct action space whose bodies contain no handwritten task logic. The signature σ is fixed by the task-family prompt, constraining the agent’s calling interface while d carries the task-specific semantics. The resulting primitives are exposed as typed pseudo-tools that can be composed freely inside a ReAct loop.

Cost and Generalization

Reasoning primitive induction’s per-instance compute is ∼24% cheaper than its closest multistep competitor AWM (∼117K vs. ∼154K tokens) The authors rule out a pure “more compute” reading by running a same-model SC@N=20 control, which lands 9 to 24pp below reasoning primitive induction on MUSR murder and object. The results hold when applied to Gemini Flash Lite, indicating the source-exceeding pattern reproduces across different model families.

Limitations and Impact

The paper notes that arithmetic-heavy tasks need an external tool, and a hybrid extension routing arithmetic through a deterministic helper while keeping the docstring’s natural-language interface recovers CoT-level performance on airline The induced primitives are typed callables with natural-language docstrings, making the agent’s reasoning vocabulary human-readable and individually auditable Deployment in high-stakes domains should pair induction with human review of the synthesized library and ongoing validation against external ground truth. The trace source uses only generic search/lookup tools, meaning the recovered structure is an emergent property of how an LLM agent reasons across instances of a task family. All paired-∆ confidence intervals against the source agent are strictly positive on the comparable subtasks. The induced library can outperform zero-shot CoT on every comparable cell and match or surpass expert-authored decompositions. The trace source uses only generic search/lookup tools—no benchmark-specific actions, no expert decomposition—so the recovered structure is not a recapitulation of supervisory signal but an emergent property of how an LLM agent reasons across instances of a task family. Each primitive is a typed pseudo-tool with an LLM-interpreted docstring: inspectable, editable, and composable inside a standard ReAct loop, rather than baked into model weights or activation-level steering vectors. Reasoning primitive induction therefore offers a training-free, single-pass route to discovering reasoning structure that has previously required expert authoring. The trace source uses only generic search/lookup tools—no benchmark-specific actions, no expert decomposition—so the recovered structure is not a recapitulation of supervisory signal but an emergent property of how an LLM agent reasons across instances of a task family. Each primitive is a typed pseudo-tool with an LLM-interpreted docstring: inspectable, editable, and composable inside a standard ReAct loop, rather than baked into model weights or activation-level steering vectors. Reasoning primitive induction therefore offers a training-free, single-pass route to discovering reasoning structure that has previously required expert authoring. The trace source uses only generic search/lookup tools—no benchmark-specific actions, no expert decomposition—so the recovered structure is not a recapitulation of supervisory signal but an emergent property of how an LLM agent reasons across instances of a task family. Each primitive is a typed pseudo-tool with an LLM-interpreted docstring: inspectable, editable, and composable inside a standard ReAct loop, rather than baked into model weights or activation-level steering vectors. Reasoning primitive induction therefore offers a training-free, single-pass route to discovering reasoning structure that has previously required expert authoring. The trace source uses only generic search/lookup tools—no benchmark-specific actions, no expert decomposition—so the recovered structure is not a recapitulation of supervisory signal but an emergent property of how an LLM agent reasons across instances of a task family. Each primitive is a typed pseudo-tool with an LLM-interpreted docstring: inspectable, editable, and composable inside a standard ReAct loop, rather than baked into model weights or activation-level steering vectors. Reasoning primitive induction therefore offers a training-free, single-pass route to discovering reasoning structure that has previously required expert authoring. The trace source uses only generic search/lookup tools—no benchmark-specific actions, no expert decomposition—so the recovered structure is not a recapitulation of supervisory signal but an emergent property of how an LLM agent reasons across instances of a task family. Each primitive is a typed pseudo-tool with an LLM-interpreted docstring: inspectable, editable, and composable inside a standard ReAct loop, rather than baked into model weights or activation-level steering vectors. Reasoning primitive induction therefore offers a training-free, single-pass route to discovering reasoning structure that has previously required expert authoring. The trace source uses only generic search/lookup tools—no benchmark-specific actions, no expert decomposition—so the recovered structure is not a recapitulation of supervisory signal but an emergent property of how an LLM agent reasons across instances of a task family. Each primitive is a typed pseudo-tool with an LLM-interpreted docstring: inspectable, editable, and composable inside a standard ReAct loop, rather than baked into model weights or activation-level steering vectors. Reasoning primitive induction therefore offers a training-free, single-pass route to discovering reasoning structure that has previously required expert authoring. The trace source uses only generic search/lookup tools—no benchmark-specific actions, no expert decomposition—so the recovered structure is not a recapitulation of supervisory signal but an emergent property of how an LLM agent reasons across instances of a task family. Each primitive is a typed pseudo-tool with an LLM-interpreted docstring: inspectable, editable, and composable inside a standard ReAct loop, rather than baked into model weights or activation-level steering vectors. Reasoning primitive induction therefore offers a training-free, single-pass route to discovering reasoning structure that has previously required expert authoring. The trace source uses only generic search/lookup tools—no benchmark-specific actions, no expert decomposition—so the recovered structure is not a recapitulation of supervisory signal but an emergent property of how an LLM agent reasons across instances of a task family. Each primitive is a typed pseudo-tool with an LLM-interpreted docstring: inspectable, editable, and composable inside a standard ReAct loop, rather than baked into model weights or activation-level steering vectors <ref:

1. textbf Trace-Based Reasoning Primitive Induction for Outperforming Source Agents in Specific Tasks: The improved system can outperform its source agent by up to +44pp on RuleArena NBA and +30pp on MUSR team allocation, by replacing the source agent's inconsistent, per-instance reconstruction with a stable specification deployed as a typed pseudo-tool.

2. textbf Discovery of Expert-Level Decompositions Without Expert Authoring: The system can match or surpass expert-authored decompositions by synthesizing moves from successful rollouts into typed stubs, achieving this on tasks where manual decomposition is difficult, such as MUSR team allocation (+17pp) and NatPlan meeting planning (+15pp).

3. textbf Auditable and Editable Reasoning Vocabulary: The system produces typed callables registered in a ReAct action space whose bodies contain no handwritten task logic, meaning the agent's reasoning vocabulary is human-readable and individually auditable, allowing users to edit a docstring to correct a systematic bias.