🤖 AI

Danus: Orchestrating Mathematical Reasoning Agents with Fact-Graph Memory

The paper introduces Danus, an open-source orchestration system that leverages a shared fact-graph memory to coordinate multiple parallel proof-search agents and a stateless verifier, enabling the successful construction of long, complex mathematical proofs for research-level problems in fields like algebraic geometry and combinatorics.

Original authors: Jihao Liu, Guoxiong Gao, Zeming Sun, Bin Wu, Shurui Liu, Jiedong Jiang, Haocheng Ju, Leheng Chen, Ronnie Cheng, Xiping Zhang, Bin Dong

Published 2026-07-08

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jihao Liu, Guoxiong Gao, Zeming Sun, Bin Wu, Shurui Liu, Jiedong Jiang, Haocheng Ju, Leheng Chen, Ronnie Cheng, Xiping Zhang, Bin Dong

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine trying to solve a massive, unsolved math problem that has stumped human experts for years. It's like trying to build a skyscraper while holding the blueprints in your head, but the building keeps changing shape, and you can't remember which brick goes where.

This is the challenge the Danus system tackles. Think of Danus not as a single super-brain, but as a highly organized construction crew working on a giant, complex puzzle.

Here is how Danus works, broken down into simple parts:

1. The Crew: A Main Boss and Many Workers

Instead of one AI trying to do everything at once (which often leads to confusion), Danus splits the work:

The Main Agent (The Site Manager): This is the boss. It doesn't do the heavy lifting of solving the math itself. Instead, it looks at the big picture, makes a plan, and assigns tasks. It talks to the workers, checks their progress, and decides when to change direction. It also acts as the bridge to human mathematicians, sending them "progress reports" so humans can step in if needed.
The Worker Swarm (The Builders): These are many smaller AI agents working at the same time. While the Manager is planning, the Workers are out in the field trying to prove small pieces of the puzzle. One might try to build a bridge, another might try to dig a foundation, and a third might try to prove a wall won't fall down. They work in parallel, exploring many different paths simultaneously.

2. The "Fact Graph": The Ultimate Whiteboard

The biggest problem with having many workers is that they might step on each other's toes or forget what they did five minutes ago. Danus solves this with a Fact Graph.

Imagine a giant, digital whiteboard where every single piece of information is a sticky note.

Verified Facts: When a Worker proves a small math step, they show it to a Verifier (a strict inspector). If the inspector says, "Yes, this is 100% correct," the Worker gets to stick a note on the whiteboard.
The Connections: The whiteboard doesn't just hold notes; it draws lines between them. If Note B depends on Note A, there is a line connecting them. This creates a web of truth.
Why it matters: Because the notes are connected, a Worker doesn't have to remember the whole building. They just look at the specific notes they need for their current task. If a note turns out to be wrong later, the system can rip that note and all the notes connected to it off the board, keeping the rest of the structure safe.

3. The Inspector: The Stateless Verifier

Before any note goes on the whiteboard, it must pass the Verifier.
Think of the Verifier as a strict quality control officer who has a short attention span. They look at a proof, check it against the rules and the existing notes on the board, and then immediately forget everything about it. They don't hold grudges or get confused by previous mistakes. They only care if the current proof is perfect. This ensures that only 100% accurate facts ever enter the system.

4. How They Solve Problems

The process looks like this:

The Human gives the crew a problem (e.g., "Prove this theorem about shapes").
The Manager breaks it down and tells the Workers to start exploring different angles.
The Workers try to prove small steps. They hit dead ends? They try again. They find a path? They send it to the Inspector.
The Inspector checks it. If it passes, it goes on the Fact Graph.
The Manager looks at the growing web of facts. If they see a path is stuck, they tell the workers to switch tactics. If they see a path is working, they tell them to keep going.
The Writing: Once the final proof is built on the Fact Graph, the system writes it up like a formal math paper. But here's the trick: the system writes the paper, then reads it back to the Inspector to make sure the writing didn't accidentally change the meaning of the math. If the writing is sloppy, the Inspector sends it back for a rewrite until it's perfect.

What Did They Actually Achieve?

The paper tested Danus on six very hard, real-world math problems in fields like geometry and combinatorics.

Success: In some cases, Danus solved the problem entirely on its own, from start to finish, without any human help.
Collaboration: In other cases, humans gave a tiny hint (like "try looking at it this way"), and Danus took that hint and finished the rest of the work.
Correction: In one case, Danus found a mistake in a famous math book it was using. It realized the book was wrong, threw out the bad notes, found a better source, and fixed its own proof.

The Bottom Line

Danus isn't a magic wand that solves everything instantly. It's a system for organizing intelligence. By using a "Fact Graph" to keep track of thousands of small, verified steps, and by having a team of workers explore many paths at once, Danus can build long, complex mathematical arguments that a single AI (or even a human working alone) would likely get lost in.

The paper concludes that while humans are still needed to pick the problems and give the final "thumbs up," Danus is a powerful new tool that can do the heavy lifting of building the proof itself.

Technical Summary: Danus – Orchestrating Mathematical Reasoning Agents with Fact-Graph Memory

Problem Statement

Recent Large Language Model (LLM)-based agents have demonstrated the ability to tackle research-level mathematical problems, sometimes resolving open questions. However, scaling these systems to handle long-horizon research tasks remains a significant challenge. Existing multi-agent systems often rely on a "generate–verify–revise" loop with specialized roles, but they struggle to coordinate parallel proof searches effectively. When multiple agents attempt to contribute to a single proof without robust memory management, shared contexts can become confused, irrelevant or erroneous intermediate artifacts may propagate, and performance degrades. The core problem is how to orchestrate a swarm of agents to collaboratively construct long, detailed, and correct mathematical proofs while maintaining a reliable state of truth.

Methodology

The paper proposes Danus, an orchestration system designed to scale mathematical reasoning through a shared Fact Graph that serves as a global memory-management mechanism. The system architecture enforces a strict separation of powers among three distinct agent types:

The Main Agent:
- Role: Performs global planning, coordination, and strategic interaction with human mathematicians. It does not perform detailed derivations.
- Function: It interprets the problem, consults high-level strategy models (e.g., GPT-5.5-pro) when needed, decomposes the problem, and assigns directions to worker agents.
- State Management: Periodically reads the Fact Graph and global memory logs to summarize the current proof state, identify dead ends, and re-assign workers to promising directions. It acts as the interface for human guidance.
Worker Agents (Swarm):
- Role: Carry out detailed proof search in parallel.
- Function: Based on the Rethlas generation agents, workers explore the problem from multiple angles (constructive and refutational) simultaneously. Each worker focuses on specific claims (lemmas, counterexamples, toy examples) rather than the entire proof.
- Interaction: Workers propose statements with supporting proofs to the verifier. They retrieve relevant facts from the Fact Graph to support their current claims but do not edit the graph directly.
The Stateless Verifier:
- Role: The sole authority on correctness.
- Function: A stateless service that checks proposed mathematical claims before they are admitted to the Fact Graph. It reads the Fact Graph to verify dependencies and cited references.
- Reliability: Engineered to produce essentially no false positives; it rejects proofs with skipped steps or erroneous references.

The Fact Graph (Core Innovation)

The Fact Graph is a Directed Acyclic Graph (DAG) that serves as the system's single source of truth.

Structure: Nodes represent verified facts (a mathematical statement + a verifier-checked proof). Edges represent logical dependencies (i.e., Fact B relies on Fact A).
Advantages over Single Blueprints: Unlike previous systems that used a single Markdown file (which forces all workers to carry the entire accumulated context), the Fact Graph allows workers to retrieve only the specific facts relevant to their current task. This keeps the context window small and focused, reducing hallucination and interference.
Parallelism: Multiple workers can contribute to the graph simultaneously without file-locking conflicts.
Revocation: If a fact is later found to be incorrect (e.g., due to a flawed reference), it and all facts depending on it are removed from the graph, ensuring the integrity of the remaining structure.

Memory Architecture

Fact Graph: Stores only verified truths.
Global Memory: A shared context for the Main Agent and workers containing intermediate products (plans, dead ends, promising directions, constructed examples) and logs of consultations with external models.
Local Memory: Private logs for individual workers to track their specific reasoning history.

Workflow

Initialization: A human provides a problem. The Main Agent formulates a plan and assigns tasks to the worker swarm.
Parallel Search: Workers generate claims and proofs, submitting them to the Verifier. Verified facts are added to the Fact Graph.
Orchestration: The Main Agent periodically summarizes the state, consults external models for strategy, and redirects workers based on progress or stagnation.
Termination: The loop continues until the target theorem (or its refutation) appears as a verified fact in the graph.
Synthesis: The Main Agent converts the Fact Graph into a paper-style manuscript. This draft undergoes a final verification pass to correct errors introduced during the compression of facts into linear prose.

Key Contributions

Fact-Graph Orchestration: Introduces a DAG-based memory mechanism that enables scalable, parallel proof search by decoupling worker context from the global proof state, preventing the "context bloat" and interference seen in single-file approaches.
Separation of Powers: Establishes a rigorous architecture where planning, execution, and verification are strictly separated, preventing the orchestrator from introducing unverified mathematics.
Human-in-the-Loop Design: Facilitates interaction where humans provide high-level guidance and final review, while the system handles the heavy lifting of search, decomposition, and synthesis.
Robust Verification Pipeline: Demonstrates a system where a stateless verifier ensures that the Fact Graph remains a reliable source of truth, allowing for the safe accumulation of long dependency chains (up to 54 levels deep in experiments).

Results

The system was evaluated on six research-level case studies in algebraic geometry, singularity theory, and combinatorics. In all cases, a baseline GPT-5.5-pro web interface failed to produce meaningful results.

Optimal Bend-and-Break for Foliations: Danus synthesized techniques from different references to prove the optimal constant is $r+1$ . It independently identified unsatisfactory references and sought better ones.
Shokurov's Global Index Conjecture (3D): Danus autonomously decomposed the problem into five classes and discovered a Lie-theoretic solution for three classes. It required only a high-level hint (foliated minimal model program) to solve the remaining two.
Total Cartier Indices in Families: Danus bridged algebraic geometry, commutative algebra, and real algebraic geometry to prove boundedness. It corrected a misread hypothesis from a PDF source after human intervention.
Matryoshka Numbers Asymptotics: Danus solved this combinatorial problem entirely autonomously, from problem statement to finished manuscript, with zero human mathematical guidance.
Weighted Homogeneity via Logarithmic Vector Fields: Danus produced a proof via a route unanticipated by human experts. When a flawed reference was identified by humans, Danus successfully revoked the dependent facts and rebuilt the proof.
Tangent Classes of Matroids: In a controlled comparison against its predecessor (Rethlas), Danus solved a complex problem that Rethlas failed to resolve in three attempts. The Fact Graph allowed the system to manage 3,157 verified facts and dependency chains up to 54 deep, whereas Rethlas conflated distinct mathematical concepts.

Significance and Claims

The paper claims that fact-graph-based orchestration provides an effective route toward scaling mathematical reasoning agents for long-horizon research problems.

Scalability: The system successfully scales test-time computation in both width (parallel exploration of many directions) and depth (accumulating long chains of verified reasoning).
Reliability: The strict verification protocol ensures that the Fact Graph remains a trustworthy source of truth, enabling the construction of proofs that are too long and complex for a single model pass.
Collaboration: Danus demonstrates that AI agents can substantially contribute to proof construction, handling decomposition, synthesis, and error repair, while human mathematicians remain essential for problem selection, supplying missing high-level ideas, and final expert review.
Limitations: The authors modestly note that the system still requires human intervention for the hardest conceptual leaps and that the final manuscript generation, while verified, may still require human adjustments for notation and citation conventions. The system does not create new mathematical ideas ex nihilo but excels at finding paths to solutions when they exist.

The paper concludes that Danus represents a step toward collaborative mathematical research systems where AI agents are integrated with human judgment to solve open research problems.