Skip to content

STAR-PólyaMath: Multi-Agent Reasoning under Persistent Meta-Strategic Supervision

🕒 Published (v1): 2026-05-19 04:20 UTC · Source: Arxiv · link

Why this paper was selected

STAR-PólyaMath: persistent meta-strategic supervision for long-horizon math reasoning

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

STAR-PólyaMath is a multi-agent framework for long-horizon mathematical reasoning governed by a reasoning-free Python orchestrator and a persistent Meta-Strategist agent that maintains cross-attempt memory. It structures problem solving as a state machine with nested challenge-step-replan loops, achieving state-of-the-art results on eight competition-mathematics benchmarks including perfect scores on AIME 2025/2026, Putnam, and HMMT February 2026.

Problem

Existing multi-agent math reasoning systems fail on long-horizon competition problems due to three compounding pathologies: (1) hallucination accumulation — errors propagate across long trajectories without reliable inter-step detection; (2) memory fragmentation — repeated backtracking loses salient information about prior failed attempts; (3) imbalanced reasoning-tool trade-offs — agents develop systematic bias toward brute-force code execution, lacking metacognition to switch strategy when tool use becomes counterproductive. No prior system maintains persistent oversight across the full problem lifecycle.

Method

STAR-PólyaMath separates control from inference via a reasoning-free Python orchestrator that drives a four-phase explicit state machine: Exploration → Planning & Decomposition → Step-wise Execution + Challenge Loop → Solution Generation.

Three specialized LLM roles: - Reasoner: explores, decomposes into 6–10 numbered sub-goals, executes each step (natural language, symbolic math, or Python), debates challenges. - Verifier: evaluates each step via a two-gate protocol — a Goal Gate (semantic drift check: did the step actually deliver its stated sub-goal?) and a Logic Gate (correctness scaled by a hierarchical tag: [verified] for code-grounded results, [easy-verify] for calculable claims, [hard-verify] for pure mathematical arguments). Emits one of four verdicts: ACCEPT, CHALLENGE, TRACE-BACK TO STEP \(M\), or PROPOSE-REPLAN. - Meta-Strategist: runs in a single persistent session spanning the entire problem lifecycle. It retains all prior attempts, failed directions, and stalemate patterns; issues either soft strategic guidance (method selection from a predefined library, pitfall warnings) or mandatory directives (e.g., forcing pure-reasoning mode to ban further code execution when brute-force search stalls).

When a step is challenged, Reasoner and Verifier enter a structured debate loop with full session continuity; convergence failure surfaces to the Meta-Strategist as a stalemate signal. Trace-back archives steps \(M, M+1, \ldots\), resets the Reasoner session (preventing stale context carry-forward), and rescues verified intermediate results. All re-plan proposals — from any source — are routed exclusively to the Meta-Strategist, preventing the system from cycling back into previously abandoned directions.

Key Contributions

  • Reasoning-free Python orchestrator as an explicit state-machine controller, cleanly separating control flow from LLM inference and bounding error propagation deterministically.
  • Persistent Meta-Strategist with cross-attempt working memory, acting as a human-style supervisor that issues history-informed guidance or mandatory directives at key decision points.
  • Hierarchical verification tags ([verified]/[easy-verify]/[hard-verify]) enabling principled, claim-type-scaled reasoning-tool trade-offs within the challenge loop.
  • Unified re-plan authority: all re-planning routed to a single decision-maker (Meta-Strategist), preventing re-entry into exhausted solution branches.
  • Pure-reasoning mode directive: a Meta-Strategist intervention that disables code execution mid-attempt, directly correcting over-reliance on brute-force tool use.
  • SOTA on all eight evaluated competition-math benchmarks (2025–2026 releases).

Results

  • AIME 2025: 100.00% (perfect; baseline GPT-5.5 xh: 96.67%)
  • AIME 2026: 100.00% (perfect; baseline GPT-5.5 xh: 97.50%)
  • Putnam 2025: 100.00% (perfect; baseline GPT-5.5 xh: 89.58%)
  • HMMT February 2026: 100.00% (perfect; baseline GPT-5.5 xh: 97.73%)
  • MathArena Apex 2025: 93.75% vs. 80.21% (GPT-5.5 xh) — largest margin across all benchmarks
  • MathArena Apex Shortlist: 94.27% vs. 93.75% (GPT-5.5 xh)
  • IMO 2025: 88.69 vs. 70.83 (GPT-5.5 xh)
  • USAMO 2026: 99.40 vs. 98.21 (GPT-5.5 xh)
  • Backbone substitution ablations confirm gains are from framework orchestration, not model diversity: every non-homogeneous or weaker-backbone configuration underperforms the headline all-GPT-5.5-xh setting.

Limitations

  • Extremely compute-intensive: per-call time limits up to 1800 s (Reasoner), 1200 s (Verifier); wall-clock per problem can far exceed any single budget.
  • All three roles instantiated with GPT-5.5 at xhigh effort — the framework's peak performance is tied to a single frontier proprietary model tier.
  • Mixed-model configurations (e.g., GPT-5.5 Reasoner/Verifier + Claude Opus 4.7 Meta-Strategist) do not improve over homogeneous backbone, narrowing applicability.
  • Component ablations are run on GPT-5.2 (h) to manage cost; absolute ablation numbers are not representative of headline performance.
  • Table 2 and component ablation data are truncated in the provided text, so quantitative ablation magnitudes cannot be fully verified.
  • Scope is limited to competition mathematics; generalization to open-domain long-horizon reasoning is undemonstrated.

Relevance to Harnesses / Meta-Harnesses

The Python orchestrator is a canonical meta-harness: a reasoning-free control layer that owns state transitions, dispatches LLM agents, enforces timeout/retry/abort policies, and bounds error propagation through deterministic trace-back — exactly the separation of control from inference that characterizes robust agent harnesses. The persistent Meta-Strategist is a second-order harness component, a supervisor-agent whose sole function is to issue orchestration-level decisions (strategy selection, re-plan verdicts, mandatory mode switches) rather than to solve the object-level task. The nested challenge-step-replan loop architecture demonstrates how harnesses can be compositionally layered — outer loop (orchestrator state machine) governing inner loops (Reasoner-Verifier debate) with a cross-cutting persistent supervisor — a design pattern directly applicable to any long-horizon agentic harness that must avoid local optima and propagation of early errors.