The working hypothesis behind Superintelligent Group's architecture: a well-coordinated team of models can accomplish what no single model can, through specialization, parallel execution, and institutional memory that compounds across tasks. This is a claim about coordination, not model size. We tested the coordination layer by running 140+ agents for 12+ hours without mutual interference — that result validates the plumbing (locks hold, signals , state converges) but not yet the full thesis. Whether coordination-first architectures consistently outperform single-agent approaches across domains is an open empirical question that the measurement framework is designed to answer.
PIANO: coherent real-time agents
The central architectural contribution of Project Sid is PIANOParallel Information Aggregation via Neural Orchestration (Project Sid) — an agent architecture with concurrent modules (planning, talking, action, memory, etc.) plus a bottlenecked Cognitive Controller that synthesizes state and broadcasts high-level decisions so multiple real-time output streams stay coherent.: a cognitive architecture for agents that must respond quickly to humans and other agents while maintaining coherence across multiple output streams (talking, acting, social behavior, long-horizon planning). The problem is that these modules run concurrently but can produce incoherent outputs — “say one thing, do another” — unless constrained.
PIANO's solution is a bottlenecked Cognitive ControllerThe bottlenecked deliberative module inside PIANO that synthesizes state from all concurrent agent modules (planning, speech, action, memory, social) and broadcasts a unified decision downstream. The mechanism that keeps an agent coherent while allowing real-time responsiveness. that synthesizes the shared Agent StateThe shared internal representation that PIANO's Cognitive Controller synthesizes from all concurrent modules. It is the single source of truth that downstream output streams (speech, action, social behavior) read from to stay aligned. from all concurrent modules and broadcasts high-level decisions downstream, so speech and action stay aligned. The tradeoff is explicit: you exchange some raw autonomy for coherence. This is a deliberate bottleneck — the same design principle that, at the group level, motivates hierarchical aggregation: local teams reconcile their work before sending summaries outward, so the system does not drown in unreconciled updates.
Virtual Autonomous Companies
A VAC is a coordinated team of AI agents organized more like a company than a single assistant. The stack has five layers, each solving a distinct class of problem:
- Agent execution — phase-based cycles (understand → plan → execute → verify → complete) with hierarchical roles. Orchestrators (~5% of decisions, frontier models) handle strategy and task decomposition; workers (~50%, efficient models) do the building; validators (~45%, fast models) run checks. Gate-chain validationCheckpoints between execution phases (understand → plan → execute → verify → complete). Each gate checks the output of the previous phase before the next one begins, catching errors early. between phases catches errors before they propagate.
- Distributed state — CRDTsConflict-free Replicated Data Type — a data structure that multiple writers can update independently and still merge into a consistent result, with no central server required. (Shapiro et al., 2011) guarantee eventual consistencyA guarantee that all copies of shared data will converge to the same state, even if updates arrive in different orders or some messages are delayed. Not instant, but mathematically certain.: all agents converge to the same shared state regardless of message ordering or network hiccups. On top of CRDTs sits semantic lockingLocks scoped to meaningful code units (functions, classes, endpoints) rather than whole files — so multiple agents can work on the same file in parallel as long as they touch different parts. (scoped to individual functions or endpoints, not whole files) and a 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. — an append-only record of who changed what, when, and why. The DeltaLog is the audit surface that makes agent decisions inspectable after the fact.
- Collaboration primitives — the four mechanisms described in the next section.
- Workflow orchestration — integration with Linear, GitHub, and CI/CD so that agent work flows through the same review and deployment channels as human work.
- Product interfaces — REST API, CLI, web UI, and SDK.
VAC stack layers
Pod hierarchy (hierarchical aggregation)
The four coordination primitives
These are the mechanisms that prevent the coordination failures that kill multi-agent systems at scale. Each exists because omitting it was validated empirically as producing a specific class of failure. For the full narrative of how each primitive was derived from specific experimental failures, see from experiments to primitives.
- 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. — exclusive locks with TTLTime-to-Live — an expiration timer attached to a lock or cache entry. When it runs out, the lock releases automatically, preventing deadlocks from crashed processes.. If an agent , the lock expires automatically and the resource becomes available. Without Claims: edit conflicts and duplicated work.
- Creation 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. — push-based dependency handoffs. Instead of agents polling to check if something is done, the producer notifies all waiters instantly. Without Signals: blocking and wasted cycles.
- 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. — structured proposal channels with quorumThe minimum number of votes needed to approve a decision. In the VAC Forum: 60% approval and at least 2 votes. Prevents any single agent from making unilateral choices.-based voting (60% approval, minimum 2 votes). Architectural decisions are collective and documented. Without Forum: isolated decisions that contradict each other.
- 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. — institutional memory with a DigestGeneratorA component inside the Collective Brain that compresses long histories into focused summaries, so agents receive relevant context without information overload. for focused summaries, a PrecedentIndexA search index over past decisions. When an agent faces a new choice, it queries the PrecedentIndex to find structurally similar situations and their outcomes. for finding similar past decisions, and a conflict resolver for competing claims on truth. Without Collective Brain: agents repeat solved problems and accumulate contradictory beliefs.
At 140 agents, we measured ~2–5% coordination overhead, lock acquisition under 1ms, signal propagation in 10–50ms, and ~100–200 coordination events per second. The full technical walkthrough is in Virtual Autonomous Companies: how we coordinated 140+ agents without conflicts.
Hierarchical coordination
Agents are organized into podsA small group of ~3 agents that coordinate closely. Pods are the basic organizational unit — heavy coordination within the pod, lightweight signals between pods. with leads that reconcile local work before broadcasting summaries outward. The motivation is the classic scaling problem: naive all-to-all coordination grows quadratically (at 1,000 agents, 499,500 pairwise connections), while hierarchies keep coupling sub-quadratic by forcing aggregation. JIT planningJust-in-time planning — the orchestrator plans one stage at a time using current information, rather than committing to a rigid upfront plan. Adapts to new information as it arrives. means the orchestrator plans one stage at a time using the current World ModelA continuously updated internal representation of the current state of the system — tasks, agents, resources, and past decisions. The orchestrator consults it before planning each stage., so the system adapts to new information instead of rigidly following an upfront plan.
Social debt and why primitives matter
Poor coordination creates what we call social debtIn software teams: accumulated (often hidden) costs and risks caused by sub-optimal socio-technical decisions that shape the work environment and degrade teamwork, performance, and outcomes over time.: the organizational twin of technical debt. Caballero-Espinosa et al.'s Community Smells SLR catalogs 30 recurring organizational anti-patterns (Organizational SiloA community smell where tasks/teams become decoupled and dependency knowledge does not flow reliably, producing coordination breakdowns and duplicated or incompatible work., Lone WolfA community smell where individuals work independently of the team’s shared process and decisions, leading to unsanctioned changes, duplicated work, and coordination decay., Radio Silence / BottleneckA community smell where information flow is choked by overly formal structures or single intermediaries, creating delays, overload, and brittle coordination.) with a stages frameworkA stages framework for how community smells emerge and worsen over time: induction → local effects → team spreading → organizational spreading → progressive (external) impact. for how they . The paper anchors Conway's lawA principle: systems tend to mirror the communication structures of the organizations that build them. If the org is siloed, the architecture often becomes siloed too. operationally: if the coordination layer incentivizes silos or bottlenecks, the codebase will mirror those pathologies. Formal coordination primitives are a defense — Claims prevent ownership ambiguity, the Forum prevents decisions made in isolation, the Collective Brain prevents knowledge locked in one agent's context. These are the cheapest structures that prevent confusion from compounding.
Supercoordination
SupercoordinationCoordination across organizational boundaries — multiple teams, each with their own agent swarm, share dependency information and institutional memory without needing a single shared codebase or culture. extends the same four primitives across organizational boundaries. Where a VAC coordinates agents within one team, supercoordination coordinates teams of VACs that may span separate GitHub orgs, Linear workspaces, and CI pipelines. The architecture adds a second coordination layer: cross-team Claims (who owns a shared API contract), cross-team Signals (deprecation notices that propagate to every downstream consumer), cross-team Forum (structured deliberation when a breaking change affects multiple teams), and cross-team Collective Brain (institutional knowledge that survives any one team's turnover).
The gap it addresses: coordinating ten agents in one repo is a solved problem; coordinating ten teams whose only shared interface is APIs and release schedules is not. Our coordination patterns essay surveys existing patterns — Google's monorepo+Bazel, Spotify squads, Amazon ownership, Linux kernel SIGs, Kubernetes KEPs — and identifies the residual gaps that supercoordination targets. The coordination complexity scales as O(T log T × A log A) — teams times agents, both hierarchical — rather than quadratic pairwise explosion.
Supercoordination also introduces new risk: a cross-team signal that is technically correct but contextually misleading can cause coordinated failure across organizations that would have been insulated without the shared layer. Design principles like 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 consistencyA guarantee that all copies of shared data will converge to the same state, even if updates arrive in different orders or some messages are delayed. Not instant, but mathematically certain. (tolerate transient disagreement), and lazy coordination (share only what downstream teams actually need) are defenses. The full treatment is in our Supercoordination essay.
Where the math is strong and where it is not
The distributed-state layer has formal guarantees: CRDTs ensure eventual consistency regardless of message ordering or network partitions. Semantic locking via Claims provides exclusive access with automatic expiration. Above that layer, guarantees become softer. The Forum enforces quorum rules, but whether the right decision emerges from a vote is a question about agent judgment, not mechanism. The Collective Brain ensures past decisions are retrievable, but whether retrieval improves future decisions depends on index quality and precedent relevance. Being precise about this boundary — formal invariants below, empirical patterns above — is what makes the architecture honest rather than hand-wavy.
Where this sits in the landscape
Several multi-agent frameworks target overlapping problems. AutoGen (Microsoft) provides conversation-based multi-agent orchestration with human-in-the-loop hooks. CrewAI focuses on role-based agent teams with sequential or hierarchical processes. LangGraph provides stateful, graph-based agent orchestration with persistence. MetaGPT (Hong et al., 2023) encodes software development SOPs into multi-agent collaboration.
The VAC architecture differs in two structural ways. First, formal distributed state: where most frameworks use shared memory or message passing, the VAC stack uses CRDTs with mathematically proven convergence guarantees — agents cannot corrupt shared state regardless of message ordering. Second, coordination primitives as first-class abstractions: Claims, Signals, Forum, and Collective Brain are reusable mechanisms that prevent known failure classes, not ad hoc patterns wired per-project. The cost of this formalism is implementation complexity; the benefit is that coordination guarantees survive scaling from 5 agents to 140+.
Go deeper
- From experiments to primitives — how each coordination primitive was derived from specific experimental failures: write collisions, polling waste, contradictory decisions, and amnesia. The 41 design explorations, the forum coordination experiments, and the feedback loop from failure to architecture.
- Coding swarms — how agents write code together: the five-phase execution model, tool profiles, entity-based editing, CRDT world state, collaboration sessions, SWE-bench results, and how coding swarms differ from open-ended R&D swarms.
Next deep dive
Failure modes — Collective stupidity, recursive runaway, Goodhart pressure, strategic voting — what breaks when many agents share a world.
Or explore: Persistent worlds, Measurement, Human in the loop, Coordination at scale, Results.