Thinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning

Abstract: As agents take on longer and more complex problems, controlling the execution becomes a task in its own right. Each step in the run brings new control choices, like which partial work to build on, whether to start fresh, or when to stop. We introduce agentic meta-reasoning, an inference-time harness that makes these choices an explicit and structured reasoning process. Workers carry out the task-level computation, while a controller consolidates what the run has established, explores next options, assesses what each option is worth under the remaining budget, and dispatches the chosen work with context drawn from persistent memory. Between decisions the controller carries only a compact account of the run rather than replaying its full history. Our baselines span production coding agents and research harnesses, together with a Direct Control Agent using the same workers and compute budget allowance. On ProgramBench, which tests long-horizon agentic capability through program reconstruction, meta-reasoning achieves 71.5% with GPT-5.5 against 58.0% for Codex; with Opus 4.8 it achieves 67.2% against 65.5% for Claude Code. On the other benchmarks, spanning abstract reasoning, multi-domain long-horizon reasoning, and proof generation, it gains between 3.6 and 4.2 points over direct control, averaged across three frontier models. It keeps improving over the tested budget ranges where direct control plateaus, though its overhead can hurt at small budgets. Artifact-graph analysis reveals more reuse of earlier work, higher coverage of correct solutions in most settings, and nonuniform gains in final selection. These results indicate that spending computation on structured control becomes more important as agents scale to longer runs.

• The paper presents a Meta-Reasoning Agent framework that separates control from computation, improving problem-solving performance by 4.0%, 4.2%, and 3.6% on average for three benchmarks.
• The framework uses an explicit four-stage control cycle: Assess, Propose, Evaluate, and Dispatch, each with access to persistent memory and internal deliberation, with a method that does not ensure uniform improvements but rather benefits substantial computational horizons.
• The controller’s compact state remains significantly smaller than direct-control accumulated history, limiting retrieval noise but requiring effective information- retrieval strategies.

Problem formulation and central contribution

“Thinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning” (2609.38147) addresses a control problem that becomes increasingly consequential as agents execute longer inference runs. An agent must repeatedly decide which partial result to trust, whether to refine or abandon an approach, how much context to expose to a worker, whether to initiate independent exploration, and when to stop. In conventional agent architectures, these decisions are interleaved with object-level problem solving and are often made in a single control step conditioned on an expanding transcript. The paper argues that control itself should be treated as an explicit agentic computation.

The proposed Meta-Reasoning Agent separates task-level computation from inference control. Workers generate proofs, analyses, or code, while a controller reasons over the evolving state of the run. The controller maintains a compact textual state and stores full worker outputs in persistent artifact memory. It therefore need not replay the entire history at every decision point. The framework represents a run as an artifact graph: nodes are worker or controller outputs, and directed edges record which prior artifacts were selected as context for subsequent work.

The core design is an explicit four-stage control cycle:

1. Assess updates the controller’s account of what has been established, which approaches have failed, and which candidates remain promising.
2. Propose generates possible next computations, including fresh attempts, targeted verification, repair, synthesis, and stopping.
3. Evaluate estimates which proposal is worth executing under the remaining model-call budget.
4. Dispatch converts the selected proposal into a worker instruction and selects the artifact context that worker receives.

The controller stages are themselves agentic processes with access to memory and, where appropriate, additional internal deliberation. Their calls are charged against the same nominal budget as worker calls. This constraint is important: the method does not assume that additional control is free. Its claim is instead that structured control can produce enough improvement in downstream computation to compensate for its overhead.

Figure 1: Meta-reasoning separates explicit control over compact state and persistent memory from object-level worker computation.

The principal baseline is a Direct Control Agent using the same underlying models, workers, interfaces, delegation mechanism, artifact-selection capability, stopping mechanism, and nominal call budgets. Direct control chooses actions in a single turn over the accumulated history. This comparison tests the complete control design, but not the independent causal contribution of staged control, state compression, or persistent memory access.

Experimental scope and evaluation methodology

The evaluation spans four substantially different tasks: IMO ProofBench-Advanced, ARC-AGI-2, LongCoT-mini, and ProgramBench. The first three use model-call workers that produce textual artifacts. ProgramBench uses coding-agent workers capable of inspecting files, executing commands, testing implementations, and reconstructing a program from an execute-only reference binary.

The underlying models are Gemini 3.1 Pro, GPT-5.5, and Opus 4.8. Reasoning benchmarks use nominal budgets of 25, 50, and 100 model calls per problem; ProgramBench uses 400, 800, and 1200 calls because coding workers require many calls within a single assignment. Controller and worker calls are both counted, and parallel calls are summed rather than treated as one batch. Since calls can differ in token length, the paper explicitly limits its resource claim to common nominal call budgets rather than equal token cost, latency, or FLOPs.

The benchmark suite probes distinct failure modes. IMO ProofBench-Advanced evaluates proof construction using scores in $\{0,1,6,7\}$, ARC-AGI-2 requires exact grid transformation, LongCoT-mini tests long-horizon reasoning across several domains, and ProgramBench measures the fraction of hidden behavioral tests passed by reconstructed code. The external comparisons on ProgramBench include mini-SWE Agent, Claude Code, and Codex; Recursive LLM is evaluated on the reasoning tasks with modifications intended to impose a comparable model-call accounting and restrict free computation inside its workspace.

The paper supplements final accuracy with trajectory-level diagnostics. For reasoning benchmarks, intermediate solution artifacts are graded so that success can be factored into coverage—whether a correct candidate appeared anywhere in the run—and selection—whether the agent submitted a correct candidate once one existed. It also measures Type-2 AUC for worker confidence and controller verdicts, artifact-graph topology, memory operations, controller-state size, budget utilization, and frontier selection gain. This diagnostic decomposition is methodologically significant because identical final scores can conceal materially different failure modes: one run may never generate a correct answer, whereas another may generate one but discard it.

Performance across benchmarks and models

At the principal budgets—100 calls on the reasoning benchmarks and 1200 on ProgramBench—the Meta-Reasoning Agent obtains the highest reported point estimate in all 12 matched comparisons against Direct Control. Averaged across models, gains over direct control are 4.0 points on IMO ProofBench-Advanced, 4.2 points on ARC-AGI-2, and 3.6 points on LongCoT-mini. The effects are heterogeneous. Gemini 3.1 Pro receives the largest gain on IMO ProofBench-Advanced, 8.6 points, and the largest gain on LongCoT-mini, 9.2 points. ARC-AGI-2 is more consistent, with gains ranging from 2.5 to 6.7 points across models. GPT-5.5 improves only 0.4 points on LongCoT-mini, showing that the framework’s benefit is not uniform across model-task combinations.

The detailed matched results are:

Model	Benchmark	Direct control	Meta-reasoning	Difference
Gemini 3.1 Pro	IMO ProofBench-Advanced	82.7	91.3	+8.6
Gemini 3.1 Pro	ARC-AGI-2	77.5	84.2	+6.7
Gemini 3.1 Pro	LongCoT-mini	53.5	62.7	+9.2
GPT-5.5	IMO ProofBench-Advanced	93.3	94.6	+1.3
GPT-5.5	ARC-AGI-2	75.8	79.2	+3.4
GPT-5.5	LongCoT-mini	64.7	65.1	+0.4
Opus 4.8	IMO ProofBench-Advanced	78.0	80.2	+2.2
Opus 4.8	ARC-AGI-2	77.5	80.0	+2.5
Opus 4.8	LongCoT-mini	65.3	66.5	+1.2

The strongest ProgramBench result is obtained with GPT-5.5: meta-reasoning reaches 71.5% mean per-problem test-pass rate, compared with 63.7% for matched direct control and 58.0% for Codex. With Opus 4.8, it reaches 67.2%, compared with 65.3% for direct control and 65.5% for Claude Code. It exceeds mini-SWE Agent for all three models by 2.5 to 13.9 points. These external comparisons establish useful end-to-end reference points, although the matched Direct Control comparison is the more informative test of the control mechanism because the external systems differ in prompts, implementation, and native orchestration.

Figure 2: Performance across four benchmarks and three models at the principal nominal budgets.

The paper’s central empirical claim is therefore specific rather than universal: under the tested configurations, explicit control produces consistent point-estimate improvements at sufficiently large budgets, even when the underlying workers and models are held fixed. The results do not establish statistical significance for every individual difference, particularly on the 30-problem proof benchmark, but the direction of the matched comparisons is uniform.

Scaling behavior and the cost of explicit control

The budget sweeps provide the most important evidence for the paper’s scaling argument. Meta-reasoning generally consumes more of the available allowance as the nominal budget increases, whereas direct control often stops early. On ProgramBench with GPT-5.5, direct control uses approximately 18% of the 1200-call allowance, while meta-reasoning uses roughly 89% to 101% across models. The slight excess above the nominal allowance can occur because workers dispatched before the cap are allowed to complete.

This additional computation is associated with improved performance. For GPT-5.5 on ProgramBench, increasing the allowance from 400 to 1200 calls raises meta-reasoning performance from 64.1% to 71.5%; direct control remains near 64% across the same sweep. With Opus 4.8, direct control increases its actual usage from 376 to 768 calls but improves only from 62.7% to 65.3%, peaking at the intermediate budget. Thus, the result is not merely that meta-reasoning spends more calls. Its control policy determines how those calls are allocated and connected.

The method has a clear low-budget disadvantage. With Opus 4.8 at 400 ProgramBench calls, meta-reasoning scores 56.6%, below direct control’s 62.7%; GPT-5.5 also trails direct control at the smallest ProgramBench allowance. The four-stage controller incurs a fixed and variable overhead that must be amortized over a sufficiently long run. This result qualifies the paper’s scaling claim: explicit meta-reasoning is not uniformly preferable, and the relevant regime is one in which the task provides enough computational horizon for improved control to repay its cost.

Artifact topology and reuse of prior work

The artifact graphs show that meta-reasoning changes not only the quantity of computation but also its structure. On the reasoning benchmarks, it generates more worker artifacts than direct control at the main budget, while recorded dependencies increase more rapidly. For example, on IMO ProofBench-Advanced with Gemini 3.1 Pro, worker artifacts approximately double under meta-reasoning, whereas recorded dependencies increase by roughly an order of magnitude.

The same pattern appears on ProgramBench. Raising GPT-5.5’s allowance from 400 to 1200 calls produces more than 2.5 times as many worker-artifact nodes and nearly four times as many dependency edges under meta-reasoning. Direct control does not exhibit comparable graph growth. The method therefore uses additional inference budget to construct increasingly interconnected computation rather than simply generating a larger collection of independent attempts.

Figure 3: Worker-artifact topology on ProgramBench as nominal budgets increase; meta-reasoning produces larger and more interconnected computation graphs.

The graphs distinguish exploration, verification, repair, and synthesis. A root represents work launched without prior artifact context; descendants represent follow-up work based on selected earlier outputs; fan-in indicates synthesis or joint analysis of multiple artifacts. On ARC-AGI-2, for example, a direct-control run may produce several independent attempts and a few one-hop follow-ups, whereas meta-reasoning explores more attempts, links later computation to earlier results, and reaches a frontier containing multiple candidates. This structure is consistent with a controller that explicitly decides when to branch and when to reuse.

Figure 4: Example artifact graphs comparing independent attempts and dependency-rich follow-up computation under the two control policies.

The interpretation should remain bounded by the graph definition. Edges represent only controller-selected artifact context. They do not capture all information channels, all within-worker interactions, or environmental state. In ProgramBench, for instance, a coding worker may inspect and modify repository state that is not fully represented by the selected artifact context. Consequently, the graph is a useful operational trace of orchestration, not a complete causal description of computation.

Coverage, monitoring, and final selection

The paper separates the appearance of correct work from the decision to submit it. If $\mathcal{C}$ denotes the event that a run contains a correct candidate and $\mathcal{S}$ the event that its submission is correct, then $\mathcal{S}\subseteq\mathcal{C}$ and final success can be written as $$\Pr(\mathcal{S})=\Pr(\mathcal{C})\Pr(\mathcal{S}\mid\mathcal{C})$$. This decomposition provides a principled account of whether an agent is coverage-bound or selection-bound.

Meta-reasoning improves correct-candidate coverage in most evaluated settings. The largest reported increases occur with Gemini 3.1 Pro: 20 percentage points on IMO ProofBench-Advanced and 10 points on LongCoT-mini. ARC-AGI-2 improves across models, while Opus 4.8 on LongCoT-mini is approximately tied with direct control. These results imply that a substantial portion of the final performance improvement comes from generating correct work more often, not solely from selecting among a fixed set of candidates.

Monitoring quality also changes. Worker confidence can be nearly uninformative: Gemini 3.1 Pro’s worker-confidence Type-2 AUC on IMO ProofBench-Advanced is approximately 0.55, close to chance. The controller’s Assess-stage verdict reaches 0.88 on the same setting. A similar separation occurs on ARC-AGI-2. The result supports the claim that a dedicated controller can evaluate candidate quality more effectively than workers’ self-reported confidence in several settings. It does not establish calibration, however; Type-2 AUC measures ranking discrimination, not whether confidence values correspond to empirical probabilities.

Figure 5: Meta-reasoning improves correct-candidate coverage in most settings, while monitoring and final-selection gains vary by model and task.

Improved monitoring does not uniformly translate into improved final selection. On ARC-AGI-2 with GPT-5.5, meta-reasoning obtains an 11-percentage-point frontier selection gain relative to uniform choice from the run’s deepest terminal artifacts, compared with 3 points for direct control. It also improves the corresponding measure for ARC-AGI-2 with Opus 4.8 and LongCoT-mini with GPT-5.5. On LongCoT-mini with Opus 4.8, the methods are approximately tied, and with Gemini 3.1 Pro direct control is slightly better.

This nonuniformity is an important qualification. The controller can produce better assessment signals without consistently making better final commitments. In approximately 83% of ARC-AGI-2 and LongCoT-mini runs, the submitted artifact comes from the deepest terminal frontier, and roughly three-quarters of those runs contain several frontier candidates. Selection remains a difficult decision even after correct work has been found.

Persistent memory and compact controller state

The memory system performs two distinct functions. It preserves full worker artifacts for later retrieval and stores controller-authored notes that compress the evolving state of the run. The controller’s state is rewritten at each cycle, while artifacts retain stable identifiers and remain available through explicit reads.

The controller frequently revisits its own notes. Among entries retrieved at least once, controller notes receive between 4.4 and 9.8 reads on ARC-AGI-2 and LongCoT-mini, compared with 1.9 to 3.3 reads for worker artifacts. Reads and writes are concentrated in Assess and Propose, with writes outnumbering reads for every model. Assess receives new artifacts directly and therefore performs relatively few explicit reads of older work; Propose and Evaluate retrieve prior artifacts when generating and comparing candidate actions.

Figure 6: Memory operations concentrate in assessment and proposal, with repeated reads of selected controller-authored notes.

The strongest systems-level effect concerns the representation persisted between control decisions. On the reasoning benchmarks, Direct Control’s accumulated history exceeds one million characters on the longest Opus 4.8 IMO ProofBench-Advanced runs. The Meta-Reasoning Agent’s compact state remains on the order of thousands to tens of thousands of characters and often shrinks as the run progresses. On ProgramBench, the gap narrows to a factor of a few because the controller must retain increasingly detailed repository information, and its state grows over time.

Figure 7: The persisted meta-reasoning state remains far smaller than direct control’s accumulated message history, especially on long reasoning runs.

The implication is not simply reduced context length. Compact state changes the information-access policy: important details are removed from the immediate control representation but can be recovered through memory reads. This introduces a trade-off. Compression can prevent context saturation and reduce retrieval noise, but it is lossy if the controller fails to preserve a fact or fails to retrieve it when it later becomes relevant. The paper suggests that direct control’s plateau may partly reflect long-context degradation, but it does not directly isolate this mechanism through a state-length ablation.

Limitations and open questions

The principal causal limitation is that the matched comparison changes several components simultaneously: staged Assess–Propose–Evaluate–Dispatch control, compact state, persistent memory, and the associated retrieval policy. The experiments establish the value of the evaluated design as a whole, but cannot determine whether the gains arise primarily from state compression, explicit proposal generation, qualitative budget evaluation, controller memory, or their interaction. Stage-removal, state-only, memory-only, and matched-context ablations are needed for component-level attribution.

Resource matching is also incomplete. Equal model-call allowances do not imply equal token consumption, wall-clock time, or FLOPs. The systems choose to stop at different points, and the meta-reasoning controller may use substantially more controller tokens even when call counts are equal. The results therefore support a comparison under nominal call budgets, not an efficiency claim at matched monetary or latency cost.

The benchmark evidence is limited in breadth and statistical resolution. The proof benchmark contains only 30 problems, and the positive point estimates do not establish significance for each comparison. Generalization to weaker models, other task distributions, or substantially longer horizons remains open. External-agent results are configuration-specific rather than controlled architectural comparisons.

Finally, the paper reports a concrete failure mode on the chess subset of LongCoT-mini. Meta-reasoning sometimes engages in unproductive reconsideration and destabilizes an answer that was already correct. This demonstrates that additional verification is not intrinsically beneficial: a controller can over-deliberate, introduce regressions, or replace a valid solution with a less reliable revision. The paper leaves open how to detect when further checking has negative expected value and how to calibrate stopping against the risk of destabilizing correct work.

Conclusion

The paper presents agentic meta-reasoning as an inference-time control architecture in which deciding what to compute next becomes an explicit structured process. Across four benchmarks and three models, it improves all 12 matched point estimates at the principal budgets, achieves 71.5% on GPT-5.5 ProgramBench versus 63.7% for direct control, and continues to benefit from larger allowances in settings where direct control plateaus. Its runs contain more reused computation, more correct candidates in most settings, and substantially smaller persistent controller state than full-history control.

The evidence supports a narrower but important conclusion: for long-horizon agents, object-level competence is only one determinant of performance. The allocation, assessment, reuse, and termination of inference computation constitute a separate capability whose value becomes more apparent as the available run length increases.