Skill changes
/solve-maths: rounds, verifier, team
Made on 29 October 2026 in both copies of the skill; before, it took agents=N rounds=1|2.
Why
The old round 2 mixed a check with a new route that nothing checked; one checker, \(A_7\), took every candidate proof, and 3 of the 15 errors found later were its own (worked example). A fixed solve–check–solve would leave the last solve unchecked.
Parameters
| option | values | default | sets |
|---|---|---|---|
agents=\(N\) | \(N\in\{1,\dots,9\}\) | \(R\) chooses | solvers per round |
rounds=\(M\) | \(M\in\{1,2,3\}\) | \(M=2\) | rounds of solvers |
verifier=\(v\) | \(v\in\{\text{off},\text{check},\text{paired}\}\) | \(v=\text{check}\) | who checks, and when (two architectures) |
team=\(\tau\) | \(\tau\in\{\text{same},\text{new}\}\) | \(\tau=\text{same}\) | whether round \(m+1\) continues round \(m\)'s agents |
budget=\(B\) | tokens | none | when the run stops early (below) |
(run)
$$\text{run}(N,M,v,\tau):\qquad \text{Fix}\ \to\ \big[\,\text{Solve}_m\to\text{Check}_m\to\text{Review}_m\,\big]_{m=1}^{M}\ \to\ \text{Verdict},$$ $$\#\text{checkers}_m=\begin{cases}0 & v=\text{off}\\ N & v\in\{\text{check},\text{paired}\}\end{cases}\qquad \#\text{agents}=N\,\big(1+[v\ne\text{off}]\big)\cdot\begin{cases}1 & \tau=\text{same}\\ M & \tau=\text{new}\end{cases}\ \le 9.$$Under paired, \(\text{Check}_m\) runs inside \(\text{Solve}_m\), step by step. Vanilla is \(\text{run}(N,1,\text{off},\cdot)\).
Shown before launch
paired a solver and its verifier are one node in two parts./solve-maths agents=3 rounds=2 verifier=paired team=same agents in the run: 6 | parameter | value | from | | agents=N | 3 | proposed | | rounds=M | 2 | default | | verifier | paired | given | | team | same | default | R · Fix ├── [S1 │ V1] approach family 1 ├── [S2 │ V2] approach family 2 └── [S3 │ V3] approach family 3 R · Review → round 2: the same agents, continued → R · Verdict
Node per solver: off A1; check A1 → C1; paired [S1 │ V1]. Not shown when another skill calls /solve-maths with fixed settings, or in a non-interactive session; then the table goes into the README.
Same agents or new: team=
(team)
$$A_i^{(m+1)}=\begin{cases}A_i^{(m)}\ \text{continued: its own context, then the new brief} & \tau=\text{same}\\[2pt] \text{a fresh agent: the new brief only} & \tau=\text{new,}\end{cases}$$and the same for each checker \(C_i\) (or verifier \(V_i\)).
What same does with the old context
\(R\) continues \(A_i\) (SendMessage): its transcript stays verbatim and the new brief is appended at the end.
$$|c_i^{(m)}|=\sum_{k=1}^{m}\big(|b_i^{(k)}|+|w_i^{(k)}|\big)\ \le\ W,$$\(c_i^{(m)}\) the context of \(A_i\) in round \(m\), \(b_i^{(k)}\) its brief in round \(k\), \(w_i^{(k)}\) its work (files read, tool output, return), \(W\) the context window. It grows linearly, over at most \(M\le 3\) rounds; near \(W\) the harness compacts, replacing earlier turns by a summary [Anthropic]. Overflow is handled; what degrades is how well the agent uses the old part (, risk).
same is the default because most round-\(m+1\) tasks are repairs (), and a repair needs the agent's own derivation; a fresh agent pays round 1's reading again and rebuilds it from the return.
same | new | |
|---|---|---|
| knows | everything it did: its route, computations, dead ends, and the report's objections, verbatim (or summarized, after compaction) | only the brief: the report, the task and the pointers \(\Pi_i\); none of the work behind the return |
| cost | each turn re-reads \(c_i^{(m)}\), which grows by one round of work per round; prefix caching makes the repeated part cheap | \(M\) times the agents (\(\#\text{agents}\le 9\) caps \(N\) lower); each fresh agent re-reads the files |
| risk | Anchoring: it patches the step the report names instead of questioning the route; once a model is confident, its own reflection rarely produces a new idea [Liang et al.], and without outside feedback it rarely finds its own error [Huang et al.]. A continued checker re-reads the proof as it first did and misses what it missed. Long context: facts in the middle of a long context are used less reliably [Liu et al.]; accuracy falls with length alone [Hong et al.]; after compaction a repair may rest on a summary of its earlier step. | Lost work: what was tried and not written in the return (a failed computation, why a route was dropped) is gone, so it may be retried [Cognition]. No real independence: it reads the report and \(\Pi_i\), so its agreement with round \(m\) is not independent evidence either. |
| use for | repairs and closing gaps, where the report is the outside feedback that makes a second pass useful [Madaan et al.] | a second opinion on a route that the report calls refuted or blocked; a checker for a proof it has not seen |
How \(R\) assigns checks and updates the agents
(check assignment)
After \(\text{Solve}_m\), with returns \(r_1^{(m)},\dots,r_N^{(m)}\) and \(a_i\) the approach of \(A_i\):
$$\sigma_m(C_i)=r_i^{(m)}\ \text{by default},\qquad \text{brief}(C_i)=\big(\sigma_m(C_i)\ \text{verbatim},\ K(a_i)\big),\qquad C_i\ne A_i,$$\(K(a_i)\) the part of the Fix's checklist that fits \(a_i\). \(R\) may move a checker: none on a return with no candidate proof, two on the proof the verdict rests on; the total stays \(N\).
| \(A_i\)'s approach | its checker runs |
|---|---|
| cites the literature | scope: each result's number and hypotheses, quoted |
| computes | compute: reruns the script; one case by hand |
| reduces or constructs | depend, logic: each implication; definitions as in the Fix |
(update brief)
$$\text{brief}\big(A_i^{(m+1)}\big)=\big(k_i^{(m)}\ \text{verbatim},\ \text{task}_i,\ \Pi_i\big),\qquad \Pi_i\subseteq\{\text{registry entries of } A_j,\ j\ne i\},$$\(k_i^{(m)}\) the report on \(r_i^{(m)}\); a pointer in \(\Pi_i\) is an id and its statement, and the agent reads the return itself. Under same the brief also tells \(A_i\) that it keeps its context from earlier rounds and should reuse what it computed, read or ruled out, even when \(\text{task}_i\) is not its old route.
| report on \(r_i\) | \(\text{task}_i\) | \(\Pi_i\) points to |
|---|---|---|
| a critical issue | repair the step named | a checked result of \(A_j\) that could replace it |
| gaps only | close the gaps | lemmas of \(A_j\) that bear on them |
| route refuted or blocked | redirect | the route that got furthest; the counterexample |
| another agent's target open | take it over | that agent's steps on it |
| nothing left for \(A_i\) | idle: no brief this round | — |
Each pointer is a parent in tree.json, so agreement after round 1 does not count as independent. Under paired (Paired verifiers), \(\sigma_m\) is fixed (\(V_i\) checks \(S_i\)), \(K(a_i)\) is chosen at Fix, and \(V_i\)'s open issues are the report \(k_i\).
Verdict
\(R\) keeps every solution. A proposition proved by two routes keeps both proofs in tree.json, and the registry decides how many verdict.md presents; the rest go under "Other proofs". \(R\) writes the verdict in its own context, the Fix's plus briefs, returns, reports and registry (vanilla); after a compaction it re-reads returns/, reports/ and tree.json first.
Token budget: budget=
\(u(t)\): tokens of \(R\) and every agent since the Fix, each model call in the transcripts counted as input + cache writes + cache reads + output. scripts/budget.py recomputes it from the transcripts every 60 s and wakes \(R\) at each threshold.
\(c_m\): tokens of round \(m\); \(k_m\): agents working in it. The last \(0.2B\) pays for the verdict: in the worked example \(R\)'s own calls were 28 of 63 M tokens.
Where it is
| file › section | content |
|---|---|
| SKILL.md › Parameters | , \(\#\text{agents}\le 9\), the design shown first () |
| SKILL.md › Portfolio and rounds | Solve → Check → Review \(\times M\); , , |
| SKILL.md › Verdict | the status rule; every proof kept; the verdict's context |
| SKILL.md › Budget | the stop rule above; "stopped" in tree.json |
| references/agent-brief.md | check brief \((r,\,K(a))\); update brief \((k,\,\text{task},\,\Pi)\), with the memory line and idling; the STOP line |
| references/verifier-brief.md (new) | the four checks, the exchange, the gate |
| references/repository.md | reports/; "config": \(N, M, v, \tau\); "proofs" per proposition; README: a checks table |
| scripts/check_invariants.py (new) | I1–I6; I7–I8 under paired |
| scripts/budget.py (new) | \(u(t)\) and the stage; writes STOP |
<slug>/ one run README.md problem · criterion · portfolio · N, M, verifier, team · checks verdict.md propositions · proofs · gaps tree.json the attempt tree, with "config" tree.md the same, as text briefs/ what each agent was told, round by round returns/ agents' JSON, verbatim reports/ checkers' reports, verbatim (new) scripts/<agent>/ their computations
Earlier runs keep "rounds": 2 and no verifier in their config.