Danus: Multi-Agent Proof Orchestration System

• Danus is a multi-agent system that uses a shared fact graph to coordinate parallel proof searches and manage intermediate verified results.
• It employs distinct roles for planning, local proof search, and stateless verification, ensuring scalable and reliable mathematical reasoning.
• Case studies demonstrate its capacity to autonomously produce research-level manuscripts and handle thousands of verified facts in complex proofs.

Danus is a multi-agent orchestration system for research-level mathematical reasoning centered on a shared fact graph as a global memory-management mechanism. It combines a main agent for planning and coordination, multiple worker agents for parallel proof search, and a stateless verifier that checks proposed mathematical claims before they are admitted into the fact graph. In the reported experiments, Danus was used on six research-level case studies in algebraic geometry, singularity theory, and combinatorics; in one of them, concerning tangent classes of matroids and wonderful compactifications, the main body of a paper was produced autonomously and then reproduced with editorial comments by human authors (Liu et al., 7 Jul 2026, Cheng et al., 7 Jul 2026).

1. System definition and architectural components

Danus is not a new base model; it is an orchestration system that wires together existing LLMs so that they can explore proofs in parallel, reliably accumulate intermediate lemmas and arguments, and support long, research-scale proofs that might span hundreds of steps. Its architecture separates planning, local proof search, and verification into distinct roles, with the fact graph serving as the shared source of truth (Liu et al., 7 Jul 2026).

In the reported implementation, the core engines were multiple Rethlas worker agents, implemented as modified Codex-style agents using GPT-5.5; a main orchestrator agent built on Claude Code with Claude Opus 4.8; access to GPT-5.5 Pro as an auxiliary strategy consultant; and a formal verifier. The main agent monitored the fact graph, allocated subproblems to workers, maintained a global plan, and decided when the target theorem had been proved. Workers proposed statements and proofs, sent them to the verifier, and corrected or abandoned them depending on verification outcomes. When the central theorem appeared as a verified fact, the main agent read the fact graph, selected a subset of facts, and wrote the paper itself in LaTeX, then revised the draft with the verifier still available to improve internal consistency (Cheng et al., 7 Jul 2026).

This architecture was designed to address two bottlenecks identified for prior LLM-based mathematical agents: parallel proof search without chaos, and long-horizon reasoning with reliable state management. A plausible implication is that Danus should be understood less as a theorem prover in the narrow sense than as an agentic research workflow for informal mathematics.

2. Fact-graph memory and verification regime

The central data structure is a directed acyclic graph

$G=(V,E),$

where each node $v\in V$ is a verified fact and each edge $(u\to v)\in E$ records that the proof of $v$ depends on $u$. Each fact is stored together with its proof and logical dependencies. The graph is acyclic because the system does not admit self-supporting derivations: a new fact must be justified using earlier verified material (Liu et al., 7 Jul 2026).

The fact graph replaces the single mutable “blueprint” document used in Rethlas. This has two stated advantages. First, workers can operate on small local contexts rather than ingesting an entire evolving manuscript, which reduces context bloat and interference. Second, explicit dependency tracking makes long arguments modular: distinct clusters of lemmas can be explored independently and later combined if they enter the final proof. In the largest reported run, the matroid tangent-class case, the fact graph contained 3,157 verified facts, 8,616 dependency edges, and maximum dependency depth 54 (Liu et al., 7 Jul 2026).

Verification is performed by a stateless service. Each call is fresh and takes as input a proposed statement, a proof, and any cited facts from the graph. If verification passes, a new node is added; if verification fails, the worker revises or abandons the claim. The graph also supports revocation: if a fact is later found incorrect, that fact and all facts that transitively depend on it can be removed. This mechanism was used in the weighted-homogeneity case after a flawed definition of “nilpotent” in a reference was detected (Liu et al., 7 Jul 2026).

The system therefore treats the fact graph as a verified incremental memory rather than a narrative proof document. This suggests that Danus’s main novelty lies not in a single inference engine but in how proof state is organized, preserved, and selectively reused.

3. Orchestration, planning, and human-facing operation

The main agent functions as a global strategist and coordinator. It interprets the problem, optionally asks GPT-5.5 Pro for strategic suggestions, decomposes the problem into subgoals, assigns them to workers, periodically reads worker logs and the fact graph, summarizes the current state, and reallocates workers across promising directions. Outputs from GPT-5.5 Pro are written into memory rather than directly into the fact graph, so strategic suggestions do not count as verified mathematics (Liu et al., 7 Jul 2026).

Workers execute a generate–verify–repair loop at the level of individual claims. Typical subgoals include proving a lemma, constructing a counterexample, testing a conjectured reduction in small examples, or formalizing a method from a reference. Global memory records plans, dead ends, and examples, allowing the system to avoid re-running the same failed ideas. The process is long-running, with no preset number of iterations; reported runs lasted from about 1.5 hours to about 5 days (Liu et al., 7 Jul 2026).

Danus was explicitly designed for AI–human collaboration. Humans can ask for status, provide high-level hints, or adjust priorities. Progress reports are generated under restrictive instructions: they are not to give numerical estimates of percent completion and are not to claim that a result is proved unless it is literally present as a verified fact with matching hypotheses. Conditional arguments and incomplete approaches must be described as partial. This reporting discipline was introduced because the system designers regarded overstatement of progress as a real failure mode (Liu et al., 7 Jul 2026).

A recurring pattern in the case studies is that Danus can carry large proof searches on its own, but in some instances humans steered it by suggesting a key framework or by correcting a reading error in the literature. This suggests a division of labor in which Danus is especially effective at sustained parallel search and proof organization, while specification and conceptual reframing may still benefit from expert intervention.

4. Reported case studies and empirical profile

Danus was evaluated on six research-level case studies. The reported corpus spans foliations, singularity theory, asymptotic combinatorics, hypersurface singularities, and matroid geometry. The table summarizes the published examples (Liu et al., 7 Jul 2026).

Case study	Scale	Reported outcome
Optimal bend-and-break for foliations	5 workers; 63 verified facts; 239 failed paths	Proof completed; later revised using Campana–Păun upon human suggestion
Shokurov global index conjecture for threefold foliations	7 workers; ~8 hours first wave; 784 verified facts	Problem decomposed into five cases; final proof completed with human hint
Total Cartier indices of rational singularities in families	Multi-stage reduction; human correction of a misread dimension hypothesis	Affirmative theorem proved after repair
Factorial asymptotics of Matryoshka numbers	5 workers; ~90 minutes; 100 verified facts; depth up to 15	Existence of the limit proved with enclosure $0.00542831750 \le S \le 0.00542831848$
Weighted homogeneity via logarithmic vector fields	7 workers over two waves; 687 verified facts; 23 later revoked	Complete proof rebuilt after flawed reference was identified
Tangent classes of matroids and wonderful compactifications	7 workers; ~5 days; 3,157 verified facts; 664 in theorem closure	Verified solution where Rethlas failed three times

Two patterns are prominent. First, empirical scale varies widely: the Matryoshka-number case was essentially a focused short run, whereas the matroid tangent-class case involved hundreds of proof attempts, counterexamples, and a dependency graph of research-paper scale. Second, the fact graph appears particularly useful when search is exploratory rather than linear. In the tangent-class run, only 664 of 3,157 verified facts lay in the closure of the final theorem; the remainder represented alternative routes, scaffolding, and abandoned explorations (Liu et al., 7 Jul 2026).

The reported comparison with Rethlas is especially significant. On the matroid tangent-class problem, GPT-5.5 Pro produced no meaningful solution, Rethlas failed in three independent runs, and Danus succeeded. Since the systems shared underlying models, the reported difference is attributed to fact-graph-based memory, main-agent orchestration, and multi-agent parallel exploration rather than to a stronger underlying model (Liu et al., 7 Jul 2026).

5. The tangent-class experiment and autonomous mathematical production

The flagship demonstration is the paper “Tangent classes of matroids and wonderful compactifications” (Cheng et al., 7 Jul 2026). For every loopless matroid $M$ and every Feichtner–Yuzvinsky building set $\mathcal G$ containing the top flat, Danus constructed an integral tangent class $$T^{\mathbb Z}_{M,\mathcal G}\in K_{\mathbb Z}(M,\mathcal G)$$. In the realizable case, this class specializes to the class of the tangent bundle of the corresponding wonderful compactification; it recovers the Hilbert series of the Chow ring through Hirzebruch–Riemann–Roch; and it satisfies the expected Chern–$\alpha$ lower bounds (Cheng et al., 7 Jul 2026).

The integral tangent class is defined in the paper by

$v\in V$0

with rational and integral quotient classes constructed through a one-flat descent procedure and saturation arguments in the combinatorial $v\in V$1-ring. Danus also wrote the definitions of the integral combinatorial $v\in V$2-ring $v\in V$3, the rational combinatorial Chern character, the descended quotient Chern polynomial, and the recursive machinery used for the HRR identity and the Chern–$v\in V$4 inequalities (Cheng et al., 7 Jul 2026).

The paper reports that the main body was produced autonomously, without human mathematical guidance, by Danus, and that it solved the problem before (Cheng, 21 Jun 2026) was publicly available. At the same time, the accompanying documentation gives a more granular account of human involvement. The authors supplied only the mathematical task, did not provide mathematical hints, lemmas, or corrections during the run, and intervened only operationally; after the first full run, they pointed out that Danus had solved only the rational version, after which Danus designed and proved the integral lift. Except for the abstract, introduction, and explicit “humancomment” boxes, the mathematical body is reported as verbatim Danus output (Cheng et al., 7 Jul 2026).

Correctness in this experiment was supported at two levels. Internally, the run produced a fact graph of 3,157 verified facts, with 664 in the closure of the final integral main theorem and 629 internal supporting lemmas not explicitly stated in the paper. Externally, the human authors checked the manuscript and found one genuine gap: Lemma 4.19 was asserted with an incomplete argument, although the statement was true and the gap did not affect the main results. This is the clearest reported example of Danus functioning as a full-stack research agent rather than as a system for isolated lemma generation (Cheng et al., 7 Jul 2026).

6. Validation status, limitations, and place in the landscape

Danus is presented as complementary to both earlier LLM-based math agents and formal proof assistants. Relative to Rethlas, Aletheia, QED, ProofCouncil, and related systems, its main novelty is the combination of many parallel proof-search workers with a verified global memory. Relative to Lean, Coq, and Isabelle, it operates in informal mathematics: proofs are LaTeX-style arguments checked by a language-model-based verifier rather than by a small trusted kernel. The published interpretation is therefore not that Danus replaces formal methods, but that it may form part of a pipeline in which informal arguments and proof plans are later formalized (Liu et al., 7 Jul 2026).

The reported limitations are concrete. Danus can depend on human ideas for hard steps; manuscript quality, citation formatting, and explanatory structure may require refinement; it can misread PDFs; it can inherit defects from flawed references; and the verifier, while described as strong, is not perfect. In the weighted-homogeneity case, a flawed literature definition propagated into a proof until humans noticed the problem and the relevant facts were revoked. In the tangent-class paper, the written exposition overcompressed one argument, leaving a genuine gap in Lemma 4.19 (Liu et al., 7 Jul 2026, Cheng et al., 7 Jul 2026).

The broader significance assigned to Danus is methodological. The fact graph is proposed as a route toward scaling mathematical reasoning agents for long-horizon research problems, because it permits safe depth, modular reuse of lemmas, selective revocation, and wide parallel exploration without a single mutable proof document. Danus is also open source at https://github.com/frenzymath/Danus, which indicates that the system was introduced not only as a research result but also as a reusable platform (Liu et al., 7 Jul 2026).

Taken together, the published record depicts Danus as an orchestration framework for informal research mathematics whose distinctive contribution is the conversion of parallel LLM calls into a structured proof-building process. Its strongest evidence to date is the documented tangent-class experiment, where a large fact graph, worker coordination, and verifier-mediated memory were sufficient to reconstruct a nontrivial theory and produce a paper-scale mathematical manuscript (Cheng et al., 7 Jul 2026).