Agents are Anarchist
A framework for multi-agent coordination without hierarchy. Signals over senders. Artifacts over commands.
In 2000, David Graeber wrote "Are You An Anarchist? The Answer May Surprise You!"
His argument is simple. You'd been probably an anarchist all along. You just didn't have the word.
He passed sadly in 2020. But he left behind work that rewired how I look at debt, bureaucracy, labor, and what humans are capable of when no one's in charge.
This notes extends his insight into new territory: multi-agent systems.
The punchline: the architectures that actually work are anarchist. Builders just don't call them that.
The Core Thesis
Agents can coordinate without central control.
Hierarchy doesn't scale.
Central orchestration works for toy problems. It collapses under complexity, novelty, and real-world conditions.
If you're building multi-agent systems that work, you're probably already building anarchist systems.
The Tension
Most multi-agent architectures live here:
CONTROL ←————————————————————→ EMERGENCE
Orchestrator vs. Stigmergy
Central planning vs. Local rules
Command vs. Signal
Hierarchy vs. Horizontal
Fragile vs. Antifragile
Left side: legible, predictable, brittle. Right side: opaque, adaptive, robust.
The instinct is to reach for control. The systems that survive reach for emergence.
Mechanisms (Stolen from Biology)
Nature solved decentralized coordination billions of years ago. We're catching up.
Stigmergy
Indirect coordination through environmental traces.
Ants don't talk to each other. They lay pheromones. The trail is the message. Work stimulates more work. No manager required.
Agent A works → trace in artifact
↓
Agent B sees trace → works → trace
↓
Pattern emerges
Application: Agents coordinate through shared artifacts. The work product is the signal. Not Slack. Not a message bus. The artifact itself.
Quorum Sensing
Threshold-based collective decision-making.
Bacteria release signaling molecules. When concentration hits threshold, population shifts behavior together. No vote. No leader. Accumulation → phase transition.
Application: Decisions emerge when enough agents signal readiness. No single agent can force commitment. Threshold scales with stakes.
Mycelium Topology
Self-healing, need-based resource distribution.
Fungal networks connect forests. Resources flow toward stress. No central allocator. Network structure is the memory. Damage routes around.
Application: Information flows to where it's needed. System routes around failures. No single point of collapse.
Superposition
Hold multiple states until measurement forces collapse.
Quantum systems exist in superposition until observed. Then: one state.
Application: Explore multiple approaches in parallel. Don't commit early. Let signals accumulate. Collapse only when forced—deadline, resource constraint, external requirement.
Premature collapse destroys information.
Framework Principles
Eight principles. No fluff.
No Permanent Hierarchy
Leadership flows to capability, then away.
Any node can lead. No node always leads. Roles are contextual and fluid.
Stigmergic Signal
Coordinate through artifacts, not messages.
The work product is the communication layer. Explicit messaging is overhead.
Quorum Consensus
Decisions emerge at threshold. No forcing.
Confidence accumulates. When it crosses threshold, system commits. No single agent can override.
Late Collapse
Hold superposition until commitment required.
Explore multiple paths. Archive non-chosen paths—they contain signal for later.
Entangled Context
Shared norms enable implicit coordination.
Agents with deep shared context coordinate without messaging. Investment in alignment pays off in reduced coordination cost.
Source-Agnosticism
Evaluate signal, not sender.
Contributions have properties—confidence, latency, reversibility, stakes-awareness. Origin is metadata. Never primary.
This is where most systems fail. The instinct is to weight by agent type. That's hierarchy through the back door.
Self-Healing
Route around failure.
No single point of collapse. Damage triggers rerouting, not breakdown.
Structure = Practice
How you coordinate is what you build.
Graeber called this prefigurative politics. The structure embodies the outcome. You can't build freedom through domination.
The Test
One question:
Would this process work identically if you couldn't tell which source was which?
- If knowing the source changes weight → hierarchy
- If one agent type has permanent authority → you rebuilt the state
- If it passes → anarchist system
Connecting to File Over App
These principles align with how I think about data and tooling[1]:
| Anarchist Principle | Data Principle | Shared Root |
|---|---|---|
| Source-agnosticism | Interoperability | No lock-in to origin |
| Stigmergic signal | File over app | Artifacts are primary |
| Self-healing | Offline-first | No single dependency |
| Late collapse | Composability | Keep options open |
| No permanent hierarchy | Agency | User controls direction |
The pattern:
Decentralization at every layer.
No single point of control.
No single point of failure.
Whether you're designing for data sovereignty or agent coordination, the architecture is the same: distributed, artifact-centric, source-agnostic.
Failure Modes
Nothing's free. Know the risks.
| Failure | What happens | Fix |
|---|---|---|
| Decoherence | Shared context drifts | Periodic realignment |
| Premature collapse | Committed too early | Explicit soft-check vs. commit |
| Signal flood | Too many traces, noise wins | Decay functions, rate limits |
| Quorum jam | Threshold never reached | Adaptive thresholds, decompose |
| Echo chamber | Wrong path amplifies | Forced diversity, devil's advocate |
| Source bias | Weighting by origin | Blind evaluation |
Prototyping This
Minimum viable experiment. No infrastructure.
- One shared artifact (markdown, code, canvas)
- Multiple agents (different models, humans—unlabeled)
- Rule: Only communicate through artifact state
- Task: Build something non-trivial together
- Observe: Does coherence emerge? Where does it break?
That's your hour-one prototype.
More structured experiments:
- Stigmergic document: N agents edit shared file. Traces include confidence. Measure convergence.
- Blind quorum: Strip source metadata. Aggregate by signal quality. Compare against source-weighted baseline.
- Fault injection: Kill agents mid-task. Measure self-healing time.
Why This Matters
The systems that scale are anarchist in structure.
Not because of ideology. Because of physics.
Central control is a bottleneck. Single points of failure fail. Hierarchy creates information loss at every level.
Graeber spent his life arguing humans don't need bosses. That coordination without domination isn't utopian—it's how most of human history actually worked.
Turns out the same is true for agents.
Summary
Your agents are anarchist. That shouldn't surprise you.
Build systems where:
- Signals matter more than senders
- Confidence accumulates into decisions
- Work coordinates through artifacts
- Failure routes around
- No node is permanently in charge
Build systems that would work even if you couldn't tell which agent was which.
Build anarchist systems.
"Revolutionary action is not a form of self-sacrifice, a grim dedication to doing whatever it takes to achieve a future world of freedom. It is the defiant insistence on acting as if one is already free."
— David Graeber (1961–2020)
- See Prototyping Principles for the full framework on file-over-app and data sovereignty. ↩