Overview
Multi-agent systems for solving mathematical problems
- Architecture. What exactly are the agents, their responsibilities, and the rules governing communication?
- Visualization. How can you see both what the agents did and how mathematical conclusions depend on their work?
- Audit. How can you establish that the system is operating correctly, independently of whether its proposed mathematics is correct? (Audit)
The run record
Agents and messages
(agent, root, message)
- Agent. One language-model session with its own context: it reads text, may run tools, and writes text. A run has agents \(\mathcal A=\{R,A_1,\dots,A_N\}\).
- Root. \(R\) is an agent of the same kind as the \(A_i\), not a script and not an oracle. Only its role differs: it fixes the problem, writes the briefs, reads every return, and writes the registry and verdict steps.
- Messages. A brief (or a continuation) goes \(R\to A_i\); a return goes \(A_i\to R\). Agents never message each other: \(A_i\) sees another agent's work only through \(R\), quoted in a brief or in a return file \(R\) has saved.
The run Satake generation at two levels: 8 agents, 02:02–04:17 UTC.
| part of Definition 1 | source | the same idea there |
|---|---|---|
| agent = model that reads, acts with tools, writes | ReAct [Yao et al. 2023] | reasoning traces interleaved with tool actions |
| private context, communication only by messages | actors [Hewitt–Bishop–Steiger 1973] | an actor has private state and acts only by sending messages |
| root briefs workers and reads their returns | orchestrator–workers [Anthropic 2024, 2025] | a lead model splits the task, delegates to subagents, synthesizes |
| language-model agents that converse | AutoGen [Wu et al. 2023]; survey [Guo et al. 2024] | conversable agents; centralized vs. decentralized communication |
| a run as processes exchanging messages in time | [Lamport 1978] | processes, events, send and receive |
Steps and the record
(step, record)
- Step. One labelled claim, written by one agent: $$s=\big(\text{id},\ \lane(s),\ t(s),\ \kind(s),\ \st(s),\ \text{statement},\ \text{argument},\ \text{parents}(s)\big),$$ with fields as in .
- Record. The directed graph $$G=(V,E),\qquad V=\text{all steps},\qquad u\to v\in E\iff u\in\text{parents}(v).$$
| field | values | A7-22 | on whose word |
|---|---|---|---|
| id | agent name and a counter: A7-22 is the 22nd step of \(A_7\), R-4 the 4th step of \(R\) | A7-22 | |
| \(\lane(s)\) | the prefix of the id, in \(\mathcal A\) | \(A_7\) | checkable: \(s\) is in \(A_7\)'s return file |
| \(t(s)\) | UTC time \(\lane(s)\) read from its clock when it began writing \(s\) | 03:47:54 | self-reported |
| \(\kind(s)\) | what sort of step () | check | \(\lane(s)\) |
| \(\st(s)\) | proved, open, heuristic, partial, blocked, refuted, superseded | proved | \(\lane(s)\)'s claim; trusted only if a step \(w\) with \(\lane(w)\ne\lane(s)\) checks it |
| statement | the claim | A5-5 holds; Lemmas 1–3 of A5-6 hold | \(\lane(s)\) |
| argument | the proof as numbered steps, or the computation | line-by-line check; the \(m=3\) table recomputed over \(\mathbb F_2[[t]]\), \(\mathbb F_3[[t]]\) | \(\lane(s)\) |
| \(\text{parents}(s)\) | ids of the steps \(s\) uses | A5-5, A5-6 | declared, not inferred: an uncited dependence is invisible |
| \(\kind(s)\) | the step is | steps |
|---|---|---|
| idea | a direction, not yet a claim | 6 |
| lemma | a statement with a proof or a labelled gap | 36 |
| computation | an explicit calculation, with its script | 13 |
| check | a verification of cited steps, with the outcome | 30 |
| objection | a reason a cited step fails or needs a hypothesis | 9 |
| blocked | a dead end naming the missing lemma | 1 |
| verdict | the agent's conclusion for its target | 14 |
| redirect | \(R\) only: a change of direction between rounds | 1 |
\(\kind\) and \(\st\) are independent: a lemma may be open, a check may be refuted. \(\st(s)\) is what \(\lane(s)\) asserts about \(s\), not a property of \(s\); the verdict is \(R\)'s claim.
Role of a step. A step is the unit of citation: a return carries 6–19 steps, and a later step cites the one lemma it uses, not the whole return. Support, checks and every audit invariant are statements about steps and their parents.
| graph | vertex | edge \(u\to v\) | added by |
|---|---|---|---|
| Structured proof [Lamport 1995] | numbered step | \(v\) cites \(u\) in its justification | the author |
| Lean blueprint [Massot] | definition, lemma | \(v\) uses \(u\) | the author; Lean checks formalized vertices |
| Provenance [W3C PROV] | entity, attributed to an agent, generated at a time | \(v\) was derived from \(u\) | the recording system |
| Polymath [Gowers–Nielsen] | comment, wiki entry | reply, summary | participants; a moderator summarizes, as \(R\) does |
| Tree of Thoughts [Yao et al.] | partial solution | \(v\) extends \(u\) | a search program; the model scores vertices |
| Graph of Thoughts [Besta et al.] | model output | \(v\) generated or merged from \(u\) | a controller program |
| Argumentation [Dung] | argument | \(u\) attacks \(v\) | the modeller; acceptance is computed |
| Happens-before [Lamport 1978] | event | same process, or send → receive | the system's clocks |
A step is a PROV entity whose attribution, generation time and derivations are \(\lane(s)\), \(t(s)\), \(\text{parents}(s)\). As in a structured proof or a blueprint, the author of \(v\) declares every edge into \(v\); no program adds edges and nothing checks a vertex.
Graph creation
(arrival time, record at time \(\tau\))
A step of an agent enters \(G\) when the return carrying it reaches \(R\); a step of \(R\) enters when \(R\) writes it:
$$\tau(s)=\begin{cases} r(\rho), & s \text{ in the return } \rho,\ \ r(\rho)=\text{arrival time of }\rho,\\ t(s), & \lane(s)=R,\end{cases}$$ $$G_\tau=(V_\tau,E_\tau),\qquad V_\tau=\{s:\tau(s)\le\tau\},\qquad E_\tau=\{u\to v:\ v\in V_\tau,\ u\in\text{parents}(v)\},\qquad G=G_{\text{end}}.$$| stage | who acts | when | \(s\) is visible to |
|---|---|---|---|
| 1 write | \(\lane(s)\), inside its session: reads its clock, writes the fields, names the parents | \(t(s)\) | \(\lane(s)\) only |
| 2 return | \(\lane(s)\) ends or pauses its session; the return, with all its steps, reaches \(R\) | \(\tau(s)\) | \(R\) |
| 3 record | \(R\) saves the return verbatim and copies its steps into \(G\) | \(\tau(s)\) | any agent briefed or continued later |
| 4 fixed | nobody: \(s\) and \(\text{parents}(s)\) never change; later steps may cite \(s\) | after \(\tau(s)\) |
So the edges into \(v\) appear all at once, at \(\tau(v)\), and \(G_\tau\) only grows. Two consequences, both satisfied by the worked example (106 agent steps, 113 edges between agents):
$$t(s)\le\tau(s),\qquad\qquad u\to v,\ \lane(u)\ne\lane(v)\ \Longrightarrow\ \tau(u)\le t(v).$$\(\tau\) is known exactly (the harness writes returns/<agent>.returned); \(t\) only on the agent's word: A5-5…A5-10 all carry \(t=\)03:32:17, and reached \(R\) at \(\tau=\)03:42:56.
Support
(support, solved)
$$\supp(v)=\{\,u\in V:\ u\to\cdots\to v\,\}.$$The run solves the problem when its verdict \(v^\ast\) has \(\st(v^\ast)=\text{proved}\) and every \(u\in\supp(v^\ast)\) is correct, as judged by a reader outside the run.
heuristic If each step were wrong independently with probability \(\varepsilon\):
$$\Pr\big[\supp(v^\ast)\ \text{error-free}\big]=(1-\varepsilon)^{|\supp(v^\ast)|},\qquad \hat\varepsilon=\tfrac{15}{110},\ |\supp(\text{R-4})|=105\ \Rightarrow\ \approx 2\cdot10^{-7}.$$Worked example: 13 of the 105 steps below R-4 were later found wrong. So a run needs a way to find its errors.
1 · Architecture
| Vanilla multiagent rounds=1 verifier=off | Check rounds verifier=check | Paired verifiers verifier=paired | … with memory /solve-maths-mem (proposal) | |
|---|---|---|---|---|
| agents | \(R\) + \(N\le 9\) | \(R\) + \(N\) solvers + \(N\) checkers | \(R\) + \(N\le 4\) pairs \((S_i,V_i)\) | \(R\) + \(N\le 9\) |
| mathematics checked | never | whole returns, after each round | every step, as written | as /solve-maths |
| process checked | after the run | after the run | at every checkpoint, by script | as /solve-maths |
| run state | \(R\)'s context | \(R\)'s context + registry | \(R\)'s context | context + recall + archive |
Topologies
Agents never read each other, but every return is saved to the registry, and a later round's brief points its checkers and solvers there; only \(R\) writes to it.
| study | topologies | finding |
|---|---|---|
| Smith 1980; Erman et al. 1980 | contract net (a manager delegates); blackboard | the two classical designs: delegation, and a shared store |
| Yin et al. 2023 | memory, report, relay, debate | a hub spreads information fastest but loads one node |
| Li et al. 2024 | fully connected vs sparse debate, incl. MATH, GSM8K | sparse matches or beats full, at lower cost |
| Wang et al. 2024 | layered (Mixture-of-Agents) | diverse proposers help an aggregator |
| Qian et al. 2024 | DAGs up to 1000+ agents | quality logistic in \(N\); irregular graphs beat regular |
| Zhuge et al. 2024; Zhang et al. 2025 | learned edges | optimize the graph per task; fewer tokens |
| Kim et al. 2025 | independent, centralized, decentralized, hybrid | helps parallelizable tasks, hurts sequential ones |
| Cemri et al. 2025 | 7 frameworks, traces | 14 failure modes; verification is one family |
None of these counts wrong proofs; Experiment 1 varies the number of agents and whether half of them verify, and counts the mistakes.
2 · Visualization
What the agents did: (messages) and (steps), with time across and the agent down; a step appears when its return arrives. How the conclusion depends on it: the last frame, \(\supp(v^\ast)\).