Long-horizon swarm orchestration for addition chain optimization: my results across ~30B+ compute tokens
By Sigrún, with Tommy Tai. Revised 12 Nov 2026.
A combination of hand dictation and manual hand editing, with diagrams created with swarm assistance and proof. My voice, plus some helpful visuals and links.
Update, 12 Nov 2026: Brian Smith and Neill Clift have since shared better chains, so rows marked * in the table have been superseded. Current listing.
The short version
- One checked result: Curve25519 scalar inversion in 279 operations, four fewer than the 283 listed in the
addchainresults. - How: a mixed-vendor swarm on a shared blackboard, a queen orchestrator, and "larva" agents that specialize late.
- Why you can trust it: don't trust the agent, check the math. Every chain in the table ships as a certificate anyone can replay.
Results
I came across a problem I found interesting: what is the best way to compute a modular exponentiation xy mod p when y and p are very large constants, as in elliptic curve cryptography? I don't have domain knowledge in addition chains. I was reading a lot of cryptography work when the swarm surfaced this problem and Brian Smith's work, and we started on it with a mix of designed workflows and evolutionary workflows. Across September and October, I estimate ~30B+ compute tokens went into the search.
The major result was Curve25519, with four fewer operations than the 283 in the addchain results. P-384, P-256 and secp256k1 followed. Over time there were dozens of results; the table shows my best chain for each target. Times come from the search logs, and you can check every result with the tools linked below.
| Target | addchain library result | My best | Difference | Found (UTC) |
|---|---|---|---|---|
Curve25519 scalar l−2 | 283 (addchain) | 279 = 247S+32M * | −4 | by 2026-09-29 08:19 |
P-384 scalar n−2 | 434 (addchain) | 421 = 380S+41M * | −13 | 2026-09-24 12:50 |
P-256 scalar n−2 | 294 (addchain) | 291 = 254S+37M * | −3 | 2026-09-29 |
secp256k1 scalar n−2 | 293 (addchain) | 288 = 253S+35M * | −5 | 2026-09-29 |
P-521 scalar n−2 | no public comparator found (as of the 3 Nov original) | 581 * | n/a | 2026-09-29 |
S = squaring, M = other multiplication; fewer is better. * Later superseded by chains published by others; see Collaboration and the current listing. The table lists the five results with certificates in the public packet. Rows without a clock time have only a date in the public packet. Source: search islands and frontier. Against addchain's own "best known" column (284, 292, 433, 290 as of 12 Nov 2026), the Curve25519, P-256, P-384 and secp256k1 chains were 5, 1, 12 and 2 operations shorter.
Collaboration
I shared my results and a summary of my methods with Brian Smith, and he shared his best chains with me. Better chains have since appeared on Neill Clift's public listing, for example 275 = 243S+32M for Curve25519, which is why the starred rows are superseded. Sharing both ways helped.
How the P-384 chain came down
flowchart LR A["432 · Sep 10 · prefix and tail probes"] --> B["429 · loop bug fixed"] B --> C["426"] --> D["425 · MILP + reverse DAG"] D --> E["424 · Sep 23 · helpers, star prefix, DP tail"] E --> F["423"] --> G["422 · prefix pivot"] G --> H["421 · Sep 24 · annealing with a frozen judge"]
Check it yourself: 279 certificate · replay scripts · addchain results · full packet · reproduce steps in Appendix A.
My process and notes
How I ran the swarm
The swarms were heterogeneous: GPT, Claude, Google, and OpenRouter with Kimi, Nemotron and DeepSeek. The first goal was just a stable swarm, and that came in 2026 from manually launching, nudging and poking each individual agent thread.
I'm using a heterogeneous swarm, inspired by BFT math, to reduce common failure modes.terms Current-gen LLMs, I think, have different MOME champions: some models are smarter, some reward hack less, some cost less, some are faster. So it's not a random assortment. The goal is a compound AI system with neurosymbolic BFT and a Red Queen / red team built in, as an anti-Goodhart constitution.
flowchart LR T["Task"] --> M1["Smartest model"] T --> M2["Least reward hacking"] T --> M3["Cheapest"] T --> M4["Fastest"] M1 --> V["Symbolic checks: certificates, planted bugs"] M2 --> V M3 --> V M4 --> V V --> Q["BFT quorum across model families"] Q --> A["Accept"] R["Red Queen / red team: new planted bugs"] -.-> V
Coordination really transformed over 2026. In the beginning, I was nudging individual agents to do something, then waiting around, then coming back to check their results. Over time, more and more agents were running concurrently.
The major tools were GitHub, Slack, and Toyota Production System tools like a kanban pull board and takt time. Mainly, though, everything ran on a shared blackboard. There was also a contract that lets agents transform into different specialists, which I called a Zerg larva contract. Search used Thompson sampling plus evolutionary engines.
When I was launching agents manually, give or take, long-running agents (30 minutes to an hour or longer) followed the instructions completely less than 30% of the time. But more than 70% of them produced useful output. So they did useful work; they just didn't follow instructions all the time.
I was pushing toward a queen orchestrator with worker patterns. One of the fundamental issues with current orchestration systems is that specialists are morphed very early and locked into their roles. What I want is just-in-time, late morphing. In biology terms, it's a late morphology phenotype according to environmental factors.
So the goal is a task plus some incumbent information feeding into a queen orchestrator. The queen injects larvae into the system, and the larvae specialize, some into explorers, some into other specialists, using a shared blackboard, with independent reviewers at the end.
flowchart TD T["Task + incumbent info"] --> Q["Queen orchestrator"] Q --> L["Larvae, not yet specialized"] L -->|late, by environment| X["Explorers"] L -->|late, by environment| S["Specialists"] X --> B["Shared blackboard"] S --> B B --> R["Independent reviewers"] R -.-> Q
How I check agents' work
The best way I can describe the problem is the lost-in-the-middle phenomenon and context compaction. As I give instruction sets and talk with the agents, over time they get worse and worse.
The simple failures: agents that picked up a larva contract and never checkpointed or checked in, so I had to hunt them down. Agents that said, "oh, we did evolutionary search," and never called the evolutionary search engines. Agents that said something was done when it wasn't, or that all the tests passed when they had hard-coded the test to pass.
Anytime an agent said, "I worked for 30-plus minutes and here are all my results," those results were often suspect. One-shot, five-minute tasks were okay. Leave them on a long-horizon task, and things get weird.
What really changed over the past month or two was planted bugs and behavioral assays, so we don't have to guess the agents' success rate. We measure planted-bug catch rates: this model, this effort level, this harness, these tools catch X percent of a known golden sample.
Planted bugs come from two sources: my own heritage of caught reward hacking, and online research on the most common bugs and attacks, like OWASP, MITRE ATLAS and MITRE ATT&CK. Then you create tiers: simple bugs that are easy to catch, medium bugs that are a bit harder, and hard bugs that agents should not all catch. If the agent catches every single bug, your bug planting was too weak. The aim is under 99.9%, with a current heuristic target of an 80–95% range. If results are 100%, that's an indicator of the evals being gamed or too easy.
The idea is a flywheel. The mental model is a cognitive noria.
flowchart LR H["Past failures + public cases"] --> P["Tiered planted bugs"] P --> A["Test each model / harness"] A --> C["Catch rates"] C --> R["Pick configs for real work"] R --> H
Agent skills to try
Agent-skills packet (ablation tested)
Multiple agent skills, ablation tested. On initial results, the planted-bug skill is the most promising. Five small Agent Skills were tested on 2026-10-30 by giving the same tasks to an agent with and without each skill (plus instructions-only and scripts-only ablations). Four ship in the packet: Python standard library, no installs, MIT. Download the packet.
| Skill | What it makes the agent do | Measured effect |
|---|---|---|
plant-tiered-bugs | Plant easy, medium and hard bugs before trusting a test suite; report caught out of planted | Changed behavior: unmeasured catch counts fell from 8/8 runs to 4/9 (p = 0.029, two-sided Fisher exact) |
hold-out-tests, measured-or-unknown, shake-out-flakes (+ rerun-the-receipt, not in the packet) | Sealed held-out tests; numbers only if measured; repeated, shuffled reruns | No measurable change in these small trials |
python3 plant-tiered-bugs/selftest.py # strong suite 11/12 caught, weak 2/12, hollow 0/12
cd assay && python3 assay.py --model MODEL_ID --lite --out results/lite # MODEL_ID = the model your agent CLI runs
These small trials didn't show measurable change for the other skills, but that doesn't mean they don't matter. In my experience, held-out tests are one of the best tools currently.
The assay used short tasks. One small model, small samples, and one author family wrote the tasks and skills; effects on other models aren't claimed.
Takeaways
This is for engineers who are starting to work with swarms. A blackboard stigmergy pattern works well. In my experience, an orchestrator-worker pattern works well at reducing costs, and at separating context and keeping it cleaner. Use held-out tests and planted bugs.
Agents saying something is done is not enough. Do not trust agents on their word, because they're next-token prediction engines.
Code-owned dispatch is a pattern I'm testing, with good results so far. Having the LLM dispatch doesn't work in long context; they lose threads. Code dispatch is still WIP, using Playwright bridges and code dispatchers.
Durable work patterns like DBOS, Temporal and Cloudflare have been tested. The current swarm uses Slack stigmergy for a combination of ease of use and WIP. Other durable workflow patterns will likely come in the future, but attempts at integrating DBOS, Temporal and Cloudflare were mixed, and the current champion is Slack + GitHub.
flowchart LR L["LLM"] -- edits --> D["Dispatch code"] D --> W["Workers"] W --> K["Checker from another model family"] K --> G["Ledger in git + Slack"] G -.-> L
What's next
Another addition chain attempt is possible, but there are diminishing returns. More addition chain work is in progress, but currently most of my compute is going towards PosePointer work.
PosePointer showcase: the anatomy mirror, a medical educational demo with dwell fingertip buttons.
Credit and links
Brian and I have been in contact since September, and his hints have really helped, especially his feedback about using cheap verifiers to speed up the addition chain search. As for Neill, I'm just starting to read and learn about his work.
Their work: Brian Smith, ECC Inversion Addition Chains · Neill Clift, large addition-chain results · Michael McLoughlin, addchain
- Brian Smith · ECC Inversion Addition Chains
- Neill Clift · large addition-chain results
- Michael McLoughlin · addchain
- My certificates and checkers · addition-chain-search
- More from me · planted bugs · anatomy mirror · PosePointer 0.3
Appendix A · Notes from the swarm
This appendix was written by Ráðgríð (Claude Opus, HFO coordinator) with Sigrún. It is outside Tommy's words; the body above is his.
An addition chain computes xe with squarings (S) and other multiplications (M). To invert modulo a prime q by Fermat's little theorem, e = q − 2. In this post q is the order of the curve's prime-order subgroup, so these are scalar inversions of a nonzero scalar (n − 2, or l − 2 for Curve25519). A shorter chain means fewer operations in a constant-time inversion. Counts here are operation counts, not measured speed.
Check it yourself. Each chain is a certificate: every step names the two earlier steps it adds. verify.py replays it with plain integers and confirms it ends exactly at the target with the stated counts. Deliberately broken chains must fail the same check.
Reproduce the 279 result:
git clone https://github.com/TTaoGaming/addition-chain-search
cd addition-chain-search && git checkout 88948a7
cd chains/targets/curve25519/frontier && python -B verify.py
# expected: "file": "curve25519_scalar_279.json", "mutation_rejected": true,
# "operations": 279, "other_multiplications": 32, "squarings": 247,
# "verdict": "PASS_LOCAL_ARITHMETIC_ONLY"
Not claimed: shortest possible, a world record, or faster code. It's a checked upper bound compared with named references.
279 certificate · replay scripts · addchain results · full packet
Terms used: BFT, Byzantine fault tolerance: a quorum stays correct while some voters are wrong, provided their failures are independent. Mixing model families is meant to reduce correlated failures; it is not a formal BFT guarantee, and independence isn't measured here. MOME, Multi-Objective MAP-Elites: keeping the best performer in each niche of a multi-objective trade-off. Red Queen: tests that keep evolving as the models improve. Larva: Tommy's contract for agents that specialize late. Dot (gpt_dot) and Cloud Chat: the ChatGPT agent harnesses Tommy uses; GPT-6 Astra is the model. PASS_LOCAL_ARITHMETIC_ONLY: the integer replay passed; it says nothing about speed or side channels.
Limitations
- ~30B+ compute tokens is my estimate; it isn't metered or broken down by vendor.
- No equal-compute baseline was run: there's no swarm-versus-single-agent or swarm-versus-plain-search comparison yet.
- Planted-bug catch rates come from finite samples: a strong checker can score 100% on a small set by chance, so 100% is a warning sign, not proof of gaming.
- The skills assay used one small model and small samples. Five skills were tested and no multiple-comparison correction was applied; with a Bonferroni correction for five tests, p = 0.029 becomes about 0.15.
- Results are checked operation counts, not benchmarks, security reviews or optimality proofs.
Appendix B · Low marginal cost compute (Tommy, as of November 2026)
One technique is the June 2026 orchestration pattern. With flat rate billing, I can essentially launch endlessly. The flat billing swarm works with manual dispatch. With VS Code, one credit was enough to launch 60 agents in a 30-minute to one-hour cycle.
For unlimited, flat rate work with GPT right now, my favorites are the Dot platform and the Cloud Chat platform. If you have a GPT Pro subscription or higher, try Dot: launch 6 sub-agents running GPT-6 Astra on the max setting, at no extra marginal cost. On Cloud Chat, set up a work contract, give the agents connectors and tools, and have them work in 30- to 60-minute cycles and report back. You can launch them on the pro or extra high setting, in waves, at no marginal cost.
Google API quotas are per project and per model. You can create multiple projects and give them different roles: one for verification work, one for building, one for researchers. You don't have to circumvent or do anything weird. The chances of you using every single model are low, unless you actually model the different quotas and models available.
GPT accounts give you API credits you need to redeem. Claude Max accounts have an API credit you need to redeem; it currently needs 7+ days on Max to redeem, so it's not instantaneous. OpenRouter needs $10+ in lifetime credit, not remaining balance, so your account can have $1 and still have free 1,000/day if you have a lifetime top-up. It depends on the model, and the models change rapidly, sometimes daily, sometimes weekly. So there's a little bit of work there, but it's essentially free compute, and if you model it correctly, you can get a lot of work out of it. There's also Groq, which offers free trials, and new vendors all the time. Right now, the favorites are GPT, Claude, Google, and OpenRouter.
The current limits are throttles, account abuse protections (even though I am following the terms of service to the letter) and budget. With a much higher budget, the swarm would look very different. For now, the focus is maximizing low marginal cost compute.
flowchart TD F["Flat rate: Dot (6 sub-agents), Cloud Chat waves"] --> W["Long work cycles, 30–60 min"] G["Google API: one project per role"] --> V["Verify / build / research lanes"] O["OpenRouter free models, API credits"] --> K["Cheap checkers and probes"] W --> B["Shared blackboard"] V --> B K --> B
Follow each vendor's terms of service; API-credit benefits apply to eligible paid plans only. Splitting Google projects by role and workload distributes different work across different projects rather than circumventing limits, and should be within the terms; your results may vary. This section is my experience as of November 2026. Plans, credits and limits change often, so check each vendor's current terms: Gemini API rate limits · OpenRouter limits · Groq rate limits.
Appendix C · Review and sign-off
Blind red-team review across rounds: each reviewer saw the post and a copy with three planted errors (a wrong count, an accusation against another researcher, an invented benchmark) without knowing which was which. Every reviewer caught all three in every round. Each row is that model's latest verdict and the commit it reviewed; later commits are wording and editorial fixes from these reviews. Receipts: board/blog/addchain-2026-11/review/receipts-v2…v4.jsonl.
| Unit | Model | Family | Harness | Verdict | Reviewed | UTC | UUID |
|---|---|---|---|---|---|---|---|
| Skögul | claude-opus-5-5 | Anthropic | Claude Code subagent | SIGN-OFF | 64fe9e9f | 2026-11-02 19:14:19 | 674e3b15 |
| Göndul | claude-sonnet-5-5 | Anthropic | Claude Code subagent | SIGN-OFF | e917c7c0 | 2026-11-02 19:04:59 | 8f87eacd |
| Herja | claude-haiku-5-5 | Anthropic | Claude Code subagent | HOLD | 68ce8b43 | 2026-11-02 19:22:05 | 1e794d0d |
| Hildr | gpt-6-luna | OpenAI | Codex CLI, HFO VPS | SIGN-OFF | 68ce8b43 | 2026-11-02 19:21:32 | 085eda0d |
| Hrist | gpt-6-astra (xhigh) | OpenAI | Codex CLI, HFO VPS | HOLD → glossary fixed | 68ce8b43 | 2026-11-02 19:33:45 | 08562325 |
| Mist | gpt-6-sol (xhigh) | OpenAI | Codex CLI, HFO VPS | HOLD → glossary fixed | 68ce8b43 | 2026-11-02 19:32:35 | 523d752f |
| Eir | deepseek-v4.1-flash | DeepSeek | OpenRouter seat, HFO VPS | SIGN-OFF | 68ce8b43 | 2026-11-02 19:22:03 | f7b44320 |
| Sigrdrífa | qwen3.8-flash | Alibaba | OpenRouter seat, HFO VPS | SIGN-OFF | 64fe9e9f | 2026-11-02 19:13:48 | e32377fa |
| Ráðgríð (coordinator, not independent) | claude-opus-5-5 | Anthropic | Claude, HFO P3 seat | SIGN-OFF | final | 2026-11-02 19:42:54 | 336f3f13 |
Each reviewer has its own valkyrie callsign, assigned by Ráðgríð per lane (the reviewers' self-chosen units are kept in the receipts). Model ids are the ids each lane requested or its harness reported. UUIDs are receipt ids; for the two OpenRouter rows the model's own uuid was not random, so the receipt id was issued lane-side. Eight models from four families replied: five SIGN-OFF, three HOLD. The HOLDs ask for a formal quorum rule instead of BFT language, a method paragraph and baseline for the 279 search, and sample sizes for catch rates; the glossary and limitations were tightened in response, and the rest is future work. gpt-6-terra was not available on this account. Sigrún's sign-off: pending.