The news. In July 2026, researchers released Danus: Orchestrating Mathematical Reasoning Agents with Fact-Graph Memory. A hard proof can run for pages, and a lone model writing it alone in one context window tends to drift and admit a step that looks right but is false — and one bad step sinks the whole argument. Danus instead runs a main agent that plans, multiple worker agents that search proof directions in parallel, and a stateless verifier that checks each proposed claim before it is admitted. Verified claims become nodes in a shared fact graph, stored with their proofs and the claims they depend on, so the system builds long arguments from trusted pieces. The paper reports 6 research-level case studies across algebraic geometry, singularity theory, and combinatorics. Read the paper →
Picture a construction site building a tall stone tower. No mason cements a block until the inspector has stamped it, and every new block rests on blocks that were already stamped — so nothing bears weight until it has been checked. That inspected tower is Danus's design for a proof: a claim is a block, the stateless verifier is the inspector, and the shared fact graph is the tower of stamped blocks everyone builds on — not each agent's private sketch.
The work is split across roles. A main agent plays foreman: it holds the global plan, reads the current tower, and sends worker agents to search different proof directions at once. Each worker proposes a claim together with its proof. Before anything is trusted, the stateless verifier checks that one claim on its own — it does not re-audit the whole tower, just the new block and the already-stamped blocks it rests on — and only approved claims pass the gate into the graph. A rejected claim never becomes a foundation for the next step, which is the whole point: nothing the verifier declines to admit can be built on.
The real payoff is that the graph is the memory. Because the trusted state lives in the shared fact graph and not in any one agent's scarce context window, the proof can grow far past what a single model could hold or keep straight. The foreman periodically summarizes the tower's state and redirects workers, and because every node carries its dependency edges, the system can trace exactly which verified claims a final result stands on — the way a supervisor coordinates a team of workers around one shared board instead of separate private notebooks.
| Approach | Where the proof lives | What checks each step | Failure it leaves on the table |
|---|---|---|---|
| Single agent, one context window | The running text in the window | Nothing — the model trusts its own output | A false step poisons everything after it; long proofs overflow the window |
| Multi-agent, no shared verified state | Each agent's own context | Ad-hoc, if at all | Workers duplicate or contradict each other; no single trusted record |
| Danus (verifier-gated fact graph) | A shared graph of verified claims + dependency edges | A stateless verifier gates every claim | Trust now rests on the verifier — a wrongly-approved claim still propagates, so research-grade proofs still want a final human check |
Put rough numbers on why the gate matters (illustrative — the paper reports case studies, not these figures). Suppose a proof needs 40 verified steps, and a lone model quietly gets each step right only 97% of the time. Chain them with nothing checking, and the odds the whole proof is clean are 0.97^40 ≈ 0.30 — so it silently fails about 70% of the time, because one slip anywhere breaks it. Now gate each step: a step the verifier rejects never gets built on, and a worker can re-propose it, so a rejected step costs a retry rather than the whole proof. The proof stops needing all 40 steps right in one unbroken run — instead it is assembled only from the steps the verifier admitted.
Goes deeper in: AI Agents → Workflow Patterns → Orchestrator-Workers and Agent Engineering → Agent Teams → Supervisor / Worker
Related explainers
- MaxProof — defense-in-depth generative verifier — hardens the verifier itself; Danus makes verification a gate on shared state that every claim must clear
- AtomMem — atomic-fact agent memory — also externalizes memory into a graph, but stores conversational facts; Danus stores verified proof claims with dependency edges
- CheckRLM — in-chain retrieval fact-checking — checks facts inside one reasoning chain; Danus gates claims across a team into one shared record