Research and Prior Art¶

The external evidence the design rests on, and where to find the two internal reviews that weigh it. Read this page to find out which claim is current and how strongly it is supported; read the reviews themselves before citing any figure.

The two evidence reviews¶

Two internal reviews hold the primary-source work. They are not equal in standing.

S2 exists because a mischaracterised figure in S1 steered the architecture for four months. Every claim in S2 therefore carries an explicit status: VERIFIED, VERIFIED (SCOPED), MISCHARACTERISED, UNVERIFIED, or NOT FOUND. Check the status column before citing anything from it. UNVERIFIED means a single research pass with no independent confirmation, and a large share of the competitive and adoption findings sit there.

The two S1 claims S2 corrects:

• The -39% to -70% multi-agent effect is scoped to sequential-planning tasks. The source paper's overall range is +80.8% to -70.0%, and its own conclusion is that fit between coordination shape and task structure decides the outcome.
• arXiv:2603.27771 is a safety paper on emergent collusion and conformity. It carries no capability or coordination-cap claim and must not be cited for either.

What the reviews closed¶

S2 records seven positions as closed. Anything on this page or elsewhere in the docs that depends on one of them is wrong:

1. Organisational simulation as an output-quality mechanism.
2. Governance and agent execution as a standalone product.
3. Mechanical verification as sole merge authority.
4. Flat massive parallelism.
5. A thousand agents. The block is decomposition rather than cost or machinery.
6. Contracts precise enough to make merges mechanical.
7. The current packaging as a route to adoption.

Closing (1) and (3) is what removed organisational realism and automated verification from the set of things worth claiming. Roles, staffing, and the approval gate remain shipped machinery; what closed is the argument that simulating an organisation is why output is good.

What remains open¶

One question, and it is the one being measured: does verification at every merge hold off aggregation collapse as recursion deepens? If it does, the decomposition ceiling is per level and depth buys scale. If it does not, the ceiling is global. Nobody has published an answer and this project does not have one either, so no page may state a size of build the system handles.

Secondary gaps S2 found unexplored anywhere: no under-scoping detector exists in any published system; the classical modularity literature has never been connected to agent parallelism; nobody has measured whether decoupling a codebase first raises its partition count; and nobody has tested whether an agent that has read the code splits better than a planner that has not.

The findings the design rests on¶

Decomposition quality is the binding constraint¶

Not agent supply, and not coordination cost. Three measurements bound it: contract-first decomposition (15 to 25 files at 47% functional success, Contract-Coding arXiv:2604.13100), dependency-graph partitioning of real repositories (1 to 11 partitions across 28 projects, Co-Coder arXiv:2606.00953), and design-then-contract (14 to 22 files, CodeTeam arXiv:2606.22082). S2 reads them together as a ceiling of roughly 11 to 25 coherent independent units and calls that method-independent. Read as they stand they support something weaker: they do not share a unit (files against partitions), and it is the highest each one reached that spans 11 to 25, so no single study demonstrates the range and none of them is evidence for its lower bound.

This is a finding about published systems. Whether it applies per level of a tree or globally is the open question above.

Reasoning parallelism and work-stream parallelism are different regimes¶

Many agents debating one problem is consistently negative in the literature. Many agents each building a different independent piece of decomposed work is positively supported, including on software specifically. This distinction is how the strongest source frames its own headline result, and it is why the fan-out here dispatches independent units rather than convening a panel.

Hierarchy removes the flat-topology collapse¶

Flat peer coordination, where every agent can message every other, degrades as it widens. Hierarchical fan-out with non-coordinating workers does not carry the term that causes that collapse.

An independent judge is a triage filter, not an authority¶

This caps what may be claimed about review, and the cap matters more than the finding. Self-review misses a substantial share of a model's own semantic drift; models prefer their own family's output; a panel of nine judges yields roughly two effective independent votes; and correlated verifiers hit a blind-spot ceiling where failure decays polynomially rather than exponentially, so adding gates buys much less than the independence maths suggests. The only effective lever S2 found is decorrelation by model family, modality or evidence source, not more gates. Cooperative second review can score worse than no second review through false consensus, so disagreement has to be forced and evidence-grounded.

One consequence is implemented rather than asserted: the reviewer is structurally prevented from being the author. It does not make the output correct, and no page may say otherwise. The other, binding review to a different model family, remains a recommendation: reviewer selection weighs capability, not lineage, so two agents can share a family and therefore a blind spot.

Contracts do not survive implementation¶

Renegotiation is not an exception path, it is assumed infrastructure. A repair loop is a required component rather than a refinement.

Self-hosting is durable rather than clever¶

Every competitor S2 surveyed monetises hosted metered compute. What follows from that, that a genuinely self-hostable equivalent cannibalises their margin and is unattractive for them to build, is the inference rather than the observation: S2 records it as analysis derived from that survey rather than as a citation, and the survey reaches the products it names rather than the market.

Agent scaling¶

Kim et al., "Towards a Science of Scaling Agent Systems" evaluated 260 configurations spanning six agentic benchmarks, five canonical topologies (single-agent plus independent, centralised, decentralised and hybrid multi-agent) and three language-model families. Peer-reviewed and published as "Capable language models can outgrow the benefits of collaboration", Nature Machine Intelligence vol. 8 no. 7, pp. 1157-1172, 2026-07-24, DOI 10.1038/s42256-026-01268-y; the arXiv listing does not reflect that.

What it supports, and where each finding landed:

• Relative performance against a single-agent baseline ranges from +80.8% on decomposable financial reasoning to -70.0% on sequential planning. The degradation end is real and is what the routing decision turns on; quoting it without the positive end misrepresents the paper. Read alongside S2's correction table.
• Task decomposability is the primary predictor of multi-agent success. This is the finding the decomposition subsystem exists to act on.
• A coordination-metrics suite (efficiency, overhead, error amplification, message density, redundancy) explains a majority of performance variance. Implemented in budget/coordination_metrics.py and its collector.
• Coordination overhead has a band, above which it is counterproductive. Informs how the orchestration ratio metric is read.
• An error taxonomy (logical contradiction, numerical drift, context omission, coordination failure) with architecture-specific patterns. Carried as opt-in classification in the coordination pipeline.
• Topology can be selected from measurable task properties. Implemented in engine/routing/topology_selector.py.
• Centralised verification contains error amplification far more than independent agents do.

Why this is built rather than forked¶

Built from scratch on top of libraries, not forked from an existing framework.

The distinguishing properties are recursive decomposition into a tree of units that can be built independently, a structurally independent check on each part, self-hosted execution against any provider, and a durable observable session. S2's competitor survey found no shipping product combining more than two of the five properties it tested for, and none combining dependency-graph partitioning with an independent judge. That survey is a point observation of 2026-08-20 over the products it names, not an enumeration of the market, and it does not reach unshipped systems.

Forking a role-based or graph-based framework would mean fighting its execution model to add recursive splitting, per-part isolation and a reviewer structurally barred from being the author. None of that is a small addition to an existing loop.

For a feature-by-feature comparison against the rest of the ecosystem, see Ecosystem Comparison.

Libraries used¶

Sources¶

Internal reviews¶

• S2 Agent Parallelism Evidence Review: current; per-claim verification ledger.
• S1 Multi-Agent Architecture Decision: superseded in part by S2.
• Multi-Agent Failure Audit: failure-pattern guardrails.
• Embedding Evaluation: how memory embedding models are chosen.

Papers¶

• Kim et al., "Towards a Science of Scaling Agent Systems": agent scaling. Published as "Capable language models can outgrow the benefits of collaboration", Nature Machine Intelligence, 2026-07-24.

• Cemri et al., "Why Do Multi-Agent LLM Systems Fail?": the Multi-Agent System Failure Taxonomy (MAST), 14 failure modes in three categories, from over 1,600 annotated traces across seven frameworks. Basis of the coordination error classification.

• Gloaguen et al., "Evaluating AGENTS.md": repository context files do not generally improve task success rates and raise inference cost by over 20% on average; instructions are followed well, repository overviews are not helpful. Basis of the non-inferable-only principle for system prompts.

• Zhao et al., "LMEB: Long-horizon Memory Embedding Benchmark": 22 datasets, 193 zero-shot retrieval tasks across episodic, dialogue, semantic and procedural memory. The paper's own framing is that LMEB and MTEB measure orthogonal capabilities, so MTEB standing does not carry over to memory retrieval. Adopted as the evaluation frame for embedding model selection.

• NVIDIA, "Domain-Specific Embedding Fine-Tuning": synthetic data generation, hard negative mining and contrastive fine-tuning on a single GPU with no manual labelling. Reports a 10% gain in Recall@10 and NDCG@10 on a synthetic dataset and Recall@60 moving from 0.751 to 0.951 on one real deployment. Informs the optional embedding fine-tune pipeline.

Ecosystem¶

• MetaGPT: multi-agent SOP framework.
• ChatDev: multi-agent platform, repositioned away from the virtual-software-company framing.
• CrewAI: role-based crews paired with deterministic flows.
• AutoGen: async multi-agent framework, in maintenance.
• LiteLLM: unified LLM API gateway.
• pgvector: vector similarity search for PostgreSQL.
• sqlite-vec: vector search as a SQLite extension.
• A2A Protocol: Agent-to-Agent protocol (Linux Foundation).
• MCP Specification: Model Context Protocol.
• Langfuse Agent Comparison: framework comparison.
• Confluent Event-Driven Patterns: multi-agent architecture patterns.
• Microsoft Multi-Agent Reference Architecture: enterprise patterns.
• OpenRouter: multi-model API gateway.