LeanMarathon: Toward Reliable AI Co-Mathematicians through Long-Horizon Lean Autoformalization

Abstract: Long-horizon autoformalization of research mathematics fails not only at hard lemmas, but at scale: statements drift, dependencies tangle, context decays, and local repairs corrupt distant work. We present LeanMarathon, a multi-agent harness for reliable research-level Lean autoformalization. Its core abstraction is an evolving blueprint: a Lean file that serves simultaneously as formal proof skeleton, natural-language proof graph, and shared system of record. Four contract-scoped agents construct, audit, prove, and repair this blueprint. These agents are coordinated by a two-stage orchestrator that first stabilizes target fidelity through adversarial review and then discharges the proof directed acyclic graph (DAG) from its dynamic leaves upward in parallel CI-gated rounds. LeanMarathon turns one brittle multi-hour run into many local, recoverable, parallel transactions. We evaluate LeanMarathon on two recent research papers spanning four Erdős problems (#1051, #1196, #164, #1217). Across three autonomous runs, it formalizes all seven target theorems with no sorry, proving 258 lemmas and theorems. These results show that reliable AI co-mathematics requires not only stronger provers, but durable harnesses that preserve target fidelity across long mathematical developments. The code can be found at https://github.com/YuanheZ/LeanMarathon.

• The paper introduces a multi-agent architecture with a contract-driven orchestrator that reliably decomposes long research proofs into verifiable local steps.
• It decomposes complex proofs into discrete components, achieving 258 checked Lean lemmas and effectively managing blueprint drift and source-gaps.
• Experiments validated the system by fully formalizing 7 target theorems with 135 worker PRs, demonstrating superior fault containment compared to monolithic methods.

LeanMarathon: Reliable Long-Horizon AI-driven Lean Autoformalization

Introduction

LeanMarathon presents a paradigm for long-horizon, research-level Lean autoformalization using a multi-agent harness, addressing structural brittleness and context drift that limits existing machine-assisted mathematics. The primary goal is to construct durable AI co-mathematicians capable of transforming full research papers into complete, independently verified Lean proofs—without human intervention and with robust recovery from local defects.

Figure 1: LeanMarathon system logos.

Traditional approaches using monolithic agents degrade over long, multi-step autoformalization: statements drift from intent, dependency structure tangles, and local repairs propagate inconsistencies nonlocally, a phenomenon not addressed by simply increasing prover model strength. The conceptual innovation in LeanMarathon is a contract-driven, multi-agent architecture coordinated through a robust, evolving proof DAG (“blueprint”) and orchestrated fault containment. This orchestrator decomposes global formalization into discrete, independently verifiable and recoverable local steps.

System Architecture and Harness Principles

LeanMarathon’s infrastructure revolves around an evolving Lean file ('blueprint') capturing formal statements, associated natural-language LaTeX, and explicit dependency structure. Every node (lemma/theorem) records both Lean and prose components, explicitly bridging formal and informal representations. Proofs and statements are cross-verified: any divergence between prose and formal structure is mechanically rejected, robustly preventing silent drift.

Figure 2: Overview of LeanMarathon.

The system architecture decomposes autoformalization into four strictly contract-scoped agents:

• Blueprinter: Translates the source proof and canonical theorem statements into the initial blueprint, focusing on fine-grained modularity to minimize downstream repair radii. All proof bodies are placeholders.
• Target-Reviewer: Audits the initial skeleton, ensuring that Lean and prose statements reflect the intended theorems. It produces grouped issues for misaligned nodes but is strictly read-only.
• Worker: Discharges nodes in the evolving DAG, executing a four-phase process: misformalization audit, numeric falsification, statement polish, and Lean proof synthesis. Scope is restricted to a local file region; only local helpers are permitted.
• Refiner: Repairs blueprint-level errors, classified against the source as either 'drift' (blueprint disagreement) or 'source-gap' (proof incomplete/ambiguous). It operates on entire dynamically detected 'illness' sub-DAGs.

Each agent’s scope and allowed behaviors are meticulously locked down by deterministic MCP servers, CI contract enforcement, and explicit file partitioning, fully precluding unintentional cross-region edits or state corruption.

Orchestration: DAG-Driven Parallel Autoformalization

A key innovation is the orchestrator’s two-stage schedule:

• Stage 1: Cold start and adversarial target review are interleaved: the Blueprinter and Refiner resolve all blueprint/prose misalignments through external verification and explicit repair, not self-judgment.
• Stage 2: Proof discharge proceeds in parallel up the DAG. At each round, all dynamic leaves (nodes whose dependencies are fully proved) are assigned to separate Workers running on frozen substrate regions. Successful PRs are directly squash-merged after passing a deterministic CI gate; failures are handled as issues for the Refiner. This “many small, local recoverable transactions” model is a decisive advance over monolithic agent runs where a single error may silently poison long subsequent stretches.

  Figure 3: The DAG-based orchestration of stage 2.

Notably, the system enforces proof-dependency parity and lemma closeness, ensuring that dependency graphs are acyclic and that every lemma feeds into downstream theorems—a structural guard against drift and orphan reasoning.

Experimental Evaluation and Empirical Findings

LeanMarathon’s efficacy was demonstrated on two papers spanning four Erdős problems. Across three independent autonomous runs:

• All seven target theorems were fully formalized with no use of sorry, producing 258 independently checked Lean lemmas and theorems.
• The system successfully localized and contained defects, surfacing blueprint drift and source-gaps for repair.
• The parallel orchestration committed 135 Worker PRs without a single merge conflict, validating the effectiveness of agent isolation and region partitioning.

Numerical evidence underlined LeanMarathon’s superior robustness; e.g., on Erdős–Graham, the system performed 19 rounds and 58 Worker launches, merging 53 PRs and producing 111 Lean proof nodes with full CI verification. In contrast, a commercial monolithic baseline (Aristotle) failed on both papers after tens of hours, leaving central nodes unproved.

Key empirical phenomena included:

• The vast majority of failures and repair events involved blueprint drift rather than source-gaps, highlighting the necessity of trusted source-aware refinement.
• Formalization exposed latent mathematical gaps (“routine” steps and unarticulated hypotheses), especially where the informal argument deferred to standard analytic or probabilistic arguments absent from Lean’s libraries.
• Incremental development was empirically successful: new targets were added to an existing, completed blueprint, and the orchestrator extended the proof DAG without restarting.

Theoretical and Practical Implications

LeanMarathon crystallizes the principle that, for scalable research-level AI formalization, agent durability and system structure, not only agent intelligence, control reliability and success. The explicit separation of concerns, external deterministic verification, clear stoppage and repair rules, and mechanical region partitioning are not merely engineering details but theoretical advances in harness design.

Practically, such an orchestrated approach enables autonomous, legible, and fail-safe formalization of entire research papers—a precondition for reliable AI co-mathematicians and collaborative 'proof digestion' systems. The discipline of parallel CI-gated, region-frozen proof discharge ensures that long development runs are not brittle and can be resumed after failure with no silent context corruption.

Theoretically, the methodology clarifies a path forward for scalable autoformalization: durable artifact management, aggressive context locality, and mechanical, not agent-bestowed, trust in proof coherence. The blueprint formalism, with coupled prose and formal graphs, is essential to managing long-horizon proof graphs absent textbook-style high-level plans.

Limitations and Future Directions

LeanMarathon’s efficacy is bounded by the coverage and completeness of the supporting Lean libraries (e.g., Mathlib). When targets depend on deep, absent prerequisites (such as the algebraic number theory in certain recent AI proofs), the harness cannot synthesize missing mathematics; it reliably surfaces failure but cannot automate research-grade lemma invention.

Future research should extend blueprint-aware orchestration to integrate LLM-based premise discovery and premise-generating agents, especially in settings where existing libraries and canonical proofs are incomplete. Library extension, guided premise discovery, end-to-end model-based lean autoformalization, and reinforcement learning from formal feedback are natural next steps.

Robust, multi-agent harnesses as instantiated by LeanMarathon will be central to achieving reliable, reproducible, and scalable AI-driven mathematics—unlocking both new research workflows and new forms of interactive, explorable mathematics.

Conclusion

LeanMarathon demonstrates that reliable, research-level Lean autoformalization requires not just model-based advances but also harnesses that sustain legibility and fault containment over long DAGs of mathematical reasoning. Its multi-agent, blueprint-centered orchestrator proves that legible, recoverable, and fully verified AI co-mathematicians are achievable when design principles emphasize decomposition, external verification, contract-scoped actions, and mechanical enforcement of context and coherence. This establishes a reproducible foundation for the next decade of machine-assisted research mathematics.

[Essay summarizing "LeanMarathon: Toward Reliable AI Co-Mathematicians through Long-Horizon Lean Autoformalization" (2606.05400).]