The difference between a multi-agent demo and a civilization-scale substrate is not model size. It is whether the coordination topology holds up when large numbers of humans — each with partial attention, conflicting goals, and real-world latency — enter the system. The engineering constraints below are real; the specific scenarios are projected forward from current capabilities.
Sub-linear coupling is the prerequisite
At 10,000 participants with pairwise coordination you have ~50 million connections. Brooks's law — “adding manpower to a late software project makes it later” — is the human version of this constraint: coordination overhead grows super-linearly with team size. The historically reliable solution is hierarchical structure: teams with modular interfaces and aggregation points that summarize local state for the rest of the system. The VAC pod structure reduces coordination cost by forcing aggregation through interfaces. Supercoordination generalizes this across organizational boundaries with cross-team ClaimsAn exclusive lock on a resource (a file, function, or API endpoint). Only one agent can hold a Claim at a time. If the agent crashes, the lock expires automatically via its TTL., SignalsA push notification that a dependency is ready. Instead of agents polling to check, the producing agent sends a signal when done, and all waiting agents are notified instantly., ForumA structured channel where agents propose, debate, and vote on decisions. Every proposal and vote is recorded, so the rationale behind any architectural choice is retrievable., and Collective BrainInstitutional memory that any agent can query. Stores past decisions with context, so new agents can look up what was tried before and why, rather than starting from scratch..
The design consequence: if you want 10,000 people in the loop, each with their own agent , you need charters that define what agents may decide locally without escalating, Claims that assign exclusive ownership with automatic lease expiration, Forums that convert interruptions into scheduled deliberation, and Creation Signals that propagate dependency completion through the hierarchy rather than broadcasting to everyone. Each primitive has a measured cost in the VAC stack and a known failure mode when omitted — the architecture page documents both.
Real-time swarms: agents as liaisons, routers, and memory
At large scales, the scarce resource is human attention. Agents earn their place not by replacing experts but by compressing coordination overhead: prefetching context from the Collective Brain so a contributor does not need to read 200 previous decisions before making a new one; triaging Forum proposals so humans review the high-impact subset; enforcing dependency etiquette through Creation Signals so work proceeds without blocking; summarizing DeltaLogAn append-only changelog that records who changed what, when, and why — indexed by the decision that caused the change, not just the code diff. entries into shift-handoff digests; and preserving institutional memory across time zones so night-shift contributors inherit the day-shift's rationale, not just their artifacts.
As participant count grows, the orchestrator layer becomes the binding constraint: it must aggregate signals from more pods without becoming a bottleneck. The response is hierarchical aggregation (pod leads summarize before forwarding), JIT planning (one stage at a time, adapting to new information), and lazy coordination (share only what downstream participants actually need). The optimistic scenario is a working group where thousands of contributors experience the coordination load of dozens. The realistic risk is a system that amplifies as efficiently as signal — the failure modes page treats this at length.
Open source and co-creation
Open-source development already operates at civilizational scale: shared norms, maintainer roles, tacit knowledge, conflict, and collaboration that works despite no central authority. Our coordination patterns essay surveys the mechanisms: Google's monorepo + Bazel, Linux kernel SIGs, Kubernetes KEPs, Amazon two-pizza ownership. Each solves a coordination slice; none provides a general primitive for cross-boundary dependency management when both humans and agents contribute.
But existing OSS coordination fails in specific, recurring ways. The 2016 left-pad incident broke thousands of builds because a single 11-line dependency was unpublished — no ownership primitive prevented it, no dependency signal warned consumers. The Heartbleed vulnerability in OpenSSL persisted for two years while the project was maintained by two people on a $2,000/year budget — a Lone Wolf community smell with no institutional memory to distribute the knowledge. The 2024 xz backdoor was inserted through years of social engineering against a burned-out solo maintainer — an attack vector that formal Claims (with expiration and rotation), Forum-audited merge decisions, and DeltaLog provenance chains would structurally impede if not prevent.
Adding agent swarms does not automatically fix these problems. It can amplify maintainer if agents generate more pull requests than humans can meaningfully review. The same institutional primitives apply: explicit ownership boundaries (Claims mapping to CODEOWNERS with TTL-forced rotation), merge contracts (Forum-style structured review with documented rationale), and reputation systems that reward integration skill and maintenance effort rather than idea volume.
The interesting direction is co-creation at the artifact level: agents that understand the dependency graph (Creation Signals tracking upstream/downstream across repos), replay CI in constrained sandboxes, draft patches with traceable provenance (DeltaLog entries linking each change to the Forum decision that motivated it), and participate in review as auditable actors whose reasoning is retrievable. This is structurally a VAC whose “company” is a distributed commons — and supercoordination is the mechanism for scaling it across organizational boundaries.
XR as a coordination interface
Text interfaces scale poorly for multi-party work where spatial relationships matter: who is working where, what changed in the scene, which region is contested. Humans absorb parallel spatial state faster than they parse threaded text — extended reality exploits that bandwidth asymmetry. When the coordination primitives are spatial by nature (Claims on physical regions, Signals about observable changes, Forum proposals attached to specific objects), a shared 3D workspace is a natural interface.
A concrete scenario: a mixed group of people and agents collaborating in a shared XR environment — a factory layout, a research facility, a construction site. Claims are visible as spatial volumes. Forum proposals are pinned to the assets they affect, so deliberation happens around the contested object. Collective Brain precedents surface as contextual annotations when a participant approaches a region where a similar decision was made before. The agent layer compresses coordination overhead the same way it does in text-based VAC runs, but the human interface is spatial, which means the sensemaking bandwidth is significantly higher.
The limiting factor is semantic interoperability: everyone (human and agent) must agree on what objects mean, both technically and organizationally. That requires standardized scene graphs, agreed-upon ownership conventions, and the same hierarchical attention-routing that makes large-scale text coordination work: local detail within your pod, aggregated summaries from neighboring pods, strategic overviews from the orchestrator layer. My earlier work on holoportation telehealth explored a simpler version of the same problem — shared spatial state between remote and local participants.
Hard limits and honest risks
Latency budgets: at 10,000 participants, even O(n log n) coordination produces a large volume of events per cycle — manageable only if the hierarchy is deep enough and aggregation points fast enough. Deeper hierarchies introduce root-bottleneck risk.
Adversarial participants: an open swarm with agent-mediated coordination is a new attack surface — Forum spam, Collective Brain poisoning, Claim squatting, and signal forgery are all possible if access control is not designed in from the start. The supercoordination essay catalogs specific misuse scenarios.
IP friction: cross-team Collective Brain means institutional knowledge crosses organizational boundaries, which may violate confidentiality constraints.
Regulatory grey zones: automated decision-making in regulated domains requires clear attribution chains that current multi-agent stacks do not reliably provide, though the DeltaLog is a step in that direction.
Uncontrolled economies: Zhuge et al.'s NLSOM paper proposes Economies of MindAn NLSOM where agents pay each other for services in a shared currency, with natural-language contracts, bankruptcy for underperformers, and the ability to spawn child agents. Proposed by Zhuge et al. (2023) as a credit-assignment mechanism for multi-agent systems. where agents pay each other for services and warns explicitly: “it may not be advisable to let general EOM variants loose in uncontrolled situations.” Money-maximizing agent swarms that can acquire resources, spawn children, and form contracts create a class of risk beyond coordination failure.
Scaling to tens of thousands is plausible only where the system is modular enough that teams can fail locally without fracturing the whole. Design principles from the architecture: subsidiarityA design principle: decisions should be made at the most local level that can handle them. Only escalate when local resolution is insufficient. Reduces coordination load. (decide locally when possible), eventual consistency (tolerate transient disagreement), lazy coordination (share only what downstream teams need), and degradation over failure (graceful decline, not ). These are engineering constraints, not aspirations.
Next deep dive
Results — Photonic compiler, Cloud IDE, and meta-VAC self-design — what three experiment tracks reveal about coordination overhead, failure recovery, and recursive self-reference.
Or explore: Architecture, Failure modes, Persistent worlds, Measurement, Human in the loop.