By Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Riemann Agent: 60 Subagents, 31M Tokens, Lean-Gated Proof

An unreleased Anthropic model has made significant — not complete — progress on the Riemann Hypothesis, one of mathematics' oldest open problems, by running what is effectively a small research institute in a single run: 650 distinct ideas tested across 60 parallel subagents, spending 31 million tokens, with results confirmed by in-house mathematicians and formalized in the Lean proof assistant. Let me be precise about the headline before anything else: this is not a proof of the Riemann Hypothesis. It is progress — meaningful, machine-generated, verified-by-formal-methods progress — and the architecture behind it is the story.

What the pipeline actually did

The run is a landmark for three reasons, each of which generalizes far beyond this one problem:

1. Parallel agentic math research at frontier scale. Sixty subagents fanned out over the problem simultaneously, each exploring a different attack family, instead of one long serial reasoning session that loses the thread after step three.
2. Budgeted exploration with an idea registry. A registry hashed and deduplicated candidate ideas so two subagents never burned budget re-walking the same path. Budget is allocated to novel territory, not to re-discovery.
3. Lean formalization as the proof gate. An idea only "counted" once it compiled as a valid Lean formalization. This is the anti-hallucination pattern: a model that cannot verify its own reasoning is forced to express it in a form the machine can check.

The result is the blueprint for research agents that don't hallucinate proofs: hypotheses must compile in Lean to count. Anthropic confirmed the run internally and had in-house mathematicians validate the findings; no public paper was released.

The 60-subagent pipeline

research brief: Riemann zeta zero distributions on the critical line
       |  fan-out
       v
  +----------------------+
  |   subagents x 60     |   each proposes attack ideas
  +----------+-----------+
             v
  idea registry  (hash + dedup: no duplicate paths)
             v
  clustering + priority scoring
             v
  lemma check  (cheap, fast pre-verification)
             v
  Lean formalization gate ----x----> recycle / reject
             v
  human mathematician confirmation
             v
  consolidated findings (not a proof of the hypothesis)

The failure modes are worth naming because each stage exists to kill one. Idea generation kills the serial dead-end problem. The registry kills duplicate exploration — 31M tokens is a real budget and re-walking a path is the most expensive waste in the whole system. The lemma check is a cheap filter that keeps unsound leaps from reaching the expensive Lean stage. The Lean gate is the hard boundary: plausible-sounding but wrong mathematics dies at compile time. And the human confirmation stage keeps the output interpretable — a pile of machine-checked lemmas nobody can explain is not research, it is a black box.

Pipeline stages

Token-budget economics

The bill for a run like this is the first thing every CFO asks about, so let us price it honestly. Thirty-one million tokens is a lot but not astronomical, and the cost depends entirely on the model tier you route through — which is exactly the kind of job a workflow orchestrator should control. Approximate, illustrative numbers:

Even the worst case is cheaper than a funded research stint, and the machine runs in days, not years. But the honest caveat is that cost is not the right denominator — validated progress per token is. This run produced verified lemmas; a 31M-token session without a Lean gate might produce nothing but confident fiction. That is why the gate is the budget's best friend.

Code: a research-agent orchestrator

Here is the core pattern — parallel subagents, a dedup registry, and a Lean gate — in a compact form:

import hashlib
import json


class IdeaRegistry:
    def __init__(self):
        self.seen = set()

    def is_novel(self, idea: str) -> bool:
        key = hashlib.sha256(idea.encode()).hexdigest()
        if key in self.seen:
            return False
        self.seen.add(key)
        return True


def run_subagent(brief: str, focus: str, budget_tokens: int) -> list:
    # Stand-in for a real model call: returns candidate ideas for a focus area.
    return [f"{focus}: symmetry-based attack on the critical strip"]


def lemma_holds(claim: str) -> bool:
    # Cheap, fast pre-check before we spend tokens in Lean.
    return not claim.startswith("obviously")


def formalize_in_lean(claim: str) -> bool:
    # The proof gate: compiles in Lean or it does not count.
    return True


def main(brief: str, n_subagents: int = 60, budget: int = 31_000_000):
    registry = IdeaRegistry()
    spent = 0
    survivors = []
    per_agent = budget // n_subagents
    for i in range(n_subagents):
        focus = f"direction-{i}"
        ideas = run_subagent(brief, focus, budget_tokens=per_agent)
        for idea in ideas:
            if not registry.is_novel(idea):
                continue
            if not lemma_holds(idea):
                continue
            if not formalize_in_lean(idea):
                continue
            survivors.append(idea)
    return {"survivors": survivors, "budget_spent": spent}


result = main("Riemann zeta zero distributions on the critical line", 60, 31_000_000)
print(json.dumps(result, indent=2))

The three production lessons hidden in the snippet: the registry check runs before any expensive stage; the lemma check is deliberately cheap so the Lean gate is not the budget sink; and survivors is the only thing a human ever reads. The MCP directory has the tool-harness pieces (Lean server MCP, registry stores, subagent launchers) if you want to build this pattern against real infrastructure rather than a sketch.

The honest caveats

Three things keep this from being a hype story. First, it did not solve the Riemann Hypothesis — it made significant progress, which in this field is a multi-year outcome already, but the problem remains open. Second, 31M tokens is expensive by any standard, and the economics only close when the Lean gate keeps every token productive — the moment you remove the gate, the cost is not worth it. Third, the confirmation is internal: in-house mathematicians validated the findings, but there is no peer-reviewed paper and no public artifact yet. Treat the capabilities as real and the published details as partial.

What to build on this

The pattern transfers anywhere that has a verifiable target: formal verification, protocol analysis, theorem-heavy engineering, even audit-proofed code review. The formula is compact — fan out cheaply, deduplicate registry, gate on a compiler — and it converts the biggest weakness of LLM research agents (confident fabrication) into a compile error. Anthropic's run is the reference implementation. Your version does not need 60 subagents or 31M tokens; it needs the idea registry and the Lean gate, because those are the two stages that make the math trustable. Build them, and your research agents stop hallucinating proofs on day one.

Why budgeted exploration was the actual breakthrough

The quiet innovation in this run is not the model — it is the resource discipline. Research is traditionally the least budget-constrained activity in a lab: a mathematician follows hunches, and the cost of an idea is measured in human hours, which teams happily spend on dead ends because that is how research works. An agent version of that behavior would be catastrophic, because a dead end is still paid for in tokens, and a 31M-token run has a hard ceiling. The idea registry is what turns research into budgeted exploration: the system refuses to spend twice on the same intuition. That single rule is why 650 ideas could be tested inside the budget — exploration was wide, but it was never wasteful. Any team building a long-horizon agent that spends real money should steal this exact mechanism, because the alternative is an agent that explores bravely and bankrupts the project with confidence.

Lessons for agent-systems teams

Even if you never touch mathematics, the Riemann run carries four transferable lessons for anyone building multi-agent systems. First, parallelism is a budget strategy, not a speed strategy: the 60 subagents did not make the run faster so much as they made it more thorough, converting serial dead-ends into a wide search that only kept survivors. In production agent systems, the same logic applies — parallel subagents with a merge stage beat one long context window on coverage and on failure containment. Second, deduplication is the highest-ROI infrastructure you can build: the idea registry is a cheap hash table, and it saved the single most expensive resource in the whole system. Your agent stack almost certainly re-runs the same tool calls and re-explores the same reasoning paths; a simple cache keyed by canonicalized request will often cut spend more than any model discount. Third, a verification gate belongs at the end of every pipeline: whether your verifier is Lean, a unit-test suite, or a schema validator, the principle is identical — an output only counts when it passes the machine check, and everything before that is hypothesis. Fourth, budget must be attached to the gate: the run worked because tokens were spent on novel, verified steps rather than on unfiltered generation. If your agent spend is unmeasured, you are paying for hallucination; measure validated output per token and the economics of agent research — or any agent workload — changes overnight.