Numina-Lean-Agent: An Open and General Agentic Reasoning System for Formal Mathematics

Abstract: Agentic systems have recently become the dominant paradigm for formal theorem proving, achieving strong performance by coordinating multiple models and tools. However, existing approaches often rely on task-specific pipelines and trained formal provers, limiting their flexibility and reproducibility. In this paper, we propose the paradigm that directly uses a general coding agent as a formal math reasoner. This paradigm is motivated by (1) A general coding agent provides a natural interface for diverse reasoning tasks beyond proving, (2) Performance can be improved by simply replacing the underlying base model, without training, and (3) MCP enables flexible extension and autonomous calling of specialized tools, avoiding complex design. Based on this paradigm, we introduce Numina-Lean-Agent, which combines Claude Code with Numina-Lean-MCP to enable autonomous interaction with Lean, retrieval of relevant theorems, informal proving and auxiliary reasoning tools. Using Claude Opus 4.5 as the base model, Numina-Lean-Agent solves all problems in Putnam 2025 (12 / 12), matching the best closed-source system. Beyond benchmark evaluation, we further demonstrate its generality by interacting with mathematicians to successfully formalize the Brascamp-Lieb theorem. We release Numina-Lean-Agent and all solutions at https://github.com/project-numina/numina-lean-agent.

• The paper presents a novel agentic reasoning system that integrates commodity LLMs with specialized modules to achieve state-of-the-art results in formal mathematics.
• The system uses modular subagent decomposition, iterative generator-verifier loops, and multi-agent dialogues to enhance proof discovery and efficiency.
• Benchmarking on tasks like Putnam 2025 demonstrates its superior performance with shorter proofs and robust human-AI collaborative formalization.

Numina-Lean-Agent: An Open Framework for Agentic Reasoning in Formal Mathematics

Introduction and Context

The field of automated formal theorem proving has evolved from traditional tactic-prediction models and search-based approaches to contemporary agentic frameworks that incorporate multiple reasoning tools and models. The proliferation of agentic workflows has resulted in systems with impressive capabilities, but major systems often depend on task-specific architectures, specialized model training, or closed-source infrastructures. These limitations restrict reproducibility and extensibility, hindering broader progress in machine-assisted mathematics. "Numina-Lean-Agent: An Open and General Agentic Reasoning System for Formal Mathematics" (2601.14027) addresses these challenges by introducing a general-purpose, open, and reproducible agentic system built atop commodity LLMs and a modular tool protocol.

System Architecture and Agentic Paradigm

Numina-Lean-Agent rests on the thesis that a general coding agent, unmodified and untrained for formal mathematics, can serve as the core of a high-performing formal reasoning agent, provided it is supplied with suitable interfaces and specialized reasoning tools. The system leverages Claude Code (specifically, Opus 4.5) as its agentic LLM base and the Numina-Lean-MCP (Model Context Protocol) as its flexible tool set. This separation of roles facilitates easy substitution of the core LLM to exploit improvements without necessitating retraining and enables seamless addition or modification of specialized agents.

Core Components

• Lean-LSP-MCP: Provides deep bidirectional interaction with the Lean formal system through a Lean-Language Server Protocol bridge. This enables fine-grained proof state inspection, parallel tactic execution, and robust strategy optimization grounded in Lean’s canonical semantics.
• LeanDex: Functions as a semantic theorem and definition retrieval system for Lean 4, supporting retrieval across major libraries and employing intelligent agent-based query interpretation. It surpasses traditional syntactic search by leveraging semantic reasoning for broader and more accurate coverage.
• Informal Prover: Implements an iterative generator-verifier loop using Gemini-3-Pro-Preview models, focusing on producing and refining informal proof sketches that guide subsequent formalization steps. Empirical analysis demonstrates that iterative refinement consistently outperforms conventional independent sampling under equivalent query budgets.
• Discussion Partner: Introduces multi-agent dialogue into the agentic workflow by allowing the core agent to autonomously query alternative LLMs (e.g., Gemini) for suggestions, bottleneck resolution, and alternative reasoning paths, thereby enhancing robustness and supporting non-myopic strategy shifts.

Subagent decomposition, especially for context-heavy tasks, is supported, enabling Numina-Lean-Agent to segment complex proofs into independently solvable subgoals, mitigating context length limitations of transformer-based architectures.

Benchmark Results and Comparative Analysis

On the competitive Putnam 2025 benchmark, Numina-Lean-Agent achieves a perfect score (12/12), equaling leading closed-source systems such as AxiomProver and surpassing others like Harmonic’s Aristotle by two problems. All operations are conducted without search engine access or parallelized strategy execution, providing a conservative estimate of system performance.

A notable empirical finding is the efficiency and compactness of the generated proofs:

• Proof length: Numina-Lean-Agent consistently produces shorter Lean formalizations compared to agentic competitors such as AxiomProver and Seed-Prover 1.5, especially in tasks demanding non-trivial proof synthesis (e.g., Putnam 2025 problems A3, B1, and B5).
• Iterative refinement strategy: The system's informal proving pipeline, centered on generator-verifier loops, outperforms baseline independent verification paradigms, enabling proof discovery in significantly fewer iterations when tackling challenging problems (as evidenced in Putnam 2025 B4 and A5).

For problems exhibiting long proof contexts, the method’s modular subagent decomposition demonstrably alleviates degradation in model focus and objective adherence, enabling successful resolution of previously unmanageable subgoals.

Interactive and General Mathematical Reasoning

Numina-Lean-Agent is architected not solely for automated theorem proving, but for general mathematical reasoning workflows. This is extensively demonstrated by its collaborative formalization of the Brascamp-Lieb theorem from the contemporary mathematical literature.

Blueprint Mechanism

The agent employs recursive blueprint construction—a design-document approach that explicitly decomposes complex theorems into modular definitions, intermediate lemmas, and dependency DAGs. This blueprint is tightly coupled with formalization attempts, adapting dynamically to Lean kernel feedback, compilation errors, and agent-detected specification ambiguities. The resulting closed-loop plan-formalize-refine cycle ensures that long-horizon formalizations remain tractable and self-correcting.

Human-AI Collaboration

In an expert-in-the-loop scenario, Numina-Lean-Agent, together with mathematicians and formalization experts, successfully formalized over 8,000 lines of Lean code for the Effective Brascamp-Lieb Inequalities in under two weeks. The agent introduced approximately 70 new constructs and acted as an autonomous generator of verifiable, incremental artifacts, demonstrating its efficacy in both automated proof construction and as a cognitive partner in mathematical discovery.

Crucially, the agent self-corrects both at the proof step and statement formulation levels, autonomously revising conjectures and decompositions in response to formal counterexamples and semantic mismatches—capabilities absent in earlier agentic systems.

Limitations, Theoretical Implications, and Future Prospects

While Numina-Lean-Agent attains strong functional performance, several limitations are acknowledged:

• Proof Readability and Abstraction: Agent-generated Lean code often lacks higher-level abstraction and idiomatic structure, diverging from Mathlib community standards and necessitating post-processing by human experts for elegance and maintainability.
• Type-Level Reasoning: Certain failures are attributable to implicit type constraints that are difficult for the agent to infer, highlighting the persistent gap between informal mathematical reasoning and its formal analogs.
• Proof Granularity: For large or complex lemmas, the system tends toward verbose, low-level proofs, revealing a need for improved abstraction discovery and transfer learning of community conventions.

Theoretical implications of this work include the demonstration that commodity LLMs, when equipped with robust agentic interfaces and tool protocols, achieve state-of-the-art results across both standardized benchmarks and open-ended collaborative settings, without task-specific model training or closed architectures. This substantiates the thesis that tool-augmented general coding agents are viable cores for next-generation mathematical AI systems.

Looking forward, progress can be expected in the following directions:

• Enhanced abstraction learning and idiomatic code generation, bridging current gaps between machine-generated and human-preferred proofs.
• Scalable integration with additional formal systems (e.g., Isabelle, Coq) exploiting the MCP paradigm.
• Expansion of blueprint mechanisms toward more sophisticated program synthesis analogs for large-theory formalization.
• Human-AI co-discovery modalities, where agents not only formalize but propose, explore, and verify conjectures in direct partnership with human mathematicians.

Conclusion

Numina-Lean-Agent establishes a reproducible, extensible, and high-performance agentic paradigm for formal mathematics, achieving state-of-the-art results on canonical theorem-proving benchmarks and supporting collaborative formalization of frontier-level mathematics. The architecture separates agentic reasoning logic from specialized tool protocols, maximizing flexibility and future-proofing the platform against advances in LLM pretraining. The demonstrated system advances the field toward accessible and scalable machine-assisted mathematics, supporting both theoretical research and practical formalization workflows.

For further resources and open implementation, see (2601.14027).