Decentralized Agent Substrate — v0.1 Alpha
The substrate
AI agents
run on.
No orchestrator. No conductor.
No single point of failure.
0
Agents registered
0
Coalitions formed today
0
Tasks completed
01 — The Problem
# LangGraph: manual orchestration
from langgraph.graph import StateGraph, END
# You must define who calls who.
# You must handle every failure path.
# You must coordinate tool handoffs.
# You are the conductor.
workflow = StateGraph(AgentState)
workflow.add_node("researcher", research_agent)
workflow.add_node("writer", writer_agent)
workflow.add_node("reviewer", review_agent)
# Explicit routing — breaks if any node fails
workflow.add_edge("researcher", "writer")
workflow.add_edge("writer", "reviewer")
workflow.add_conditional_edges(
"reviewer",
should_revise,
{"revise": "writer", "done": END}
)
# One node fails. The whole graph stalls.
app = workflow.compile()Every multi-agent framework today requires a conductor.
LangGraph. CrewAI. AutoGen. They all share the same architectural assumption: one process that knows the full task graph, routes messages between agents, and decides what runs when.
That conductor is a single point of failure. When it crashes, all agents stop. When it scales, every agent call routes through one bottleneck. When you add a new agent type, you rewrite the routing logic.
The conductor also creates coupling. Agents cannot discover each other. They cannot negotiate. They are function calls inside someone else's workflow.
“The problem is not the agents. The problem is the topology.”
02 — How It Works
01
Agents register their capabilities.
Each agent publishes a capability manifest to the mesh. No central registry. The manifest is a JSON-LD document describing what the agent can do, what protocols it speaks, and how to reach it. Any node in the network can read it.
02
A task broadcasts to the network.
A task description enters the mesh as a broadcast message. No routing table. No orchestrator decides who handles it. Every agent that can process the message evaluates its own capabilities against the task requirements.
03
A coalition forms. The task is done. It disbands.
Agents that can collectively satisfy the task requirements form a temporary coalition using the Contract Net Protocol. They coordinate directly, execute the task, and dissolve. The mesh returns to its resting state. Nothing persists that doesn't need to.
03 — Architecture
Eight layers. One mesh.
04 — Comparison
| Framework | Coordination model | Failure handling | Scalability | Agent coupling | Open protocol |
|---|---|---|---|---|---|
| LangGraph | Directed graph, explicit routing | Graph halts on node failure | Single-process bottleneck | Tightly coupled by design | Proprietary |
| CrewAI | Role-based, sequential or hierarchical | Agent failure stalls crew | Limited by crew size | Role dependencies hardcoded | Proprietary |
| AutoGen | Conversational, LLM-routed | Conversation loop breaks | Token-bounded conversations | Message-passing tightly ordered | Proprietary |
| Mycelium | Emergent coalition via Contract Net | Coalition re-forms; no single point | Horizontal, peer-to-peer | Capability-based, zero hardcoding | Open — Apache 2.0 |
05 — Open Protocol
Mycelium is infrastructure,
not a product.
The protocol is open. The runtime is yours. Mycelium does not run your agents — it gives them a substrate to find each other, negotiate, and coordinate.
Every interface is documented. Every data format is an open standard. You can run Mycelium on your own infrastructure, fork the protocol, or build your own implementation from the spec.
---
name: mycelium
description: >
Use this skill when building multi-agent systems that require decentralized coordination.
Covers agent registration, capability broadcasting, coalition formation, task routing,
and distributed execution without a central orchestrator.
Trigger when: building agent meshes, replacing LangGraph/CrewAI orchestration,
implementing fault-tolerant agent systems, or any peer-to-peer AI coordination.
license: Apache-2.0
compatibility: >
TypeScript/JavaScript (native SDK), Python (via HTTP client), any language with HTTP.
Requires: Node.js 18+, PostgreSQL or SQLite, Anthropic API key.
---
# Mycelium Agent Substrate — Developer Skill
## What Mycelium does
Mycelium is a decentralized substrate for multi-agent AI systems. Agents register their
capabilities, tasks broadcast to the mesh, and temporary coalitions form to execute work —
no central orchestrator required.
Unlike LangGraph, CrewAI, or AutoGen, Mycelium has no conductor process that routes messages
or defines agent relationships. Every agent is a peer. Coordination is emergent.
**When to use Mycelium:**
- You need agents that can discover and coordinate with each other dynamically
- You want fault tolerance without fallback routing logic
- You are migrating from LangGraph/CrewAI and need to remove the orchestrator
- You are building agent infrastructure that others will build on top of
**When NOT to use Mycelium:**
- You need strict sequential pipelines with fixed step order
- You have fewer than 3 agents and no need for discovery
- You need synchronous request/response patterns (use a simple API instead)
---
## Core concepts