Typically users interact with AI through a single chat interface. For software development in particular, this is a poor strategy, as it creates a copy-paste loop where context is lost as errors and code are shuttled manually between environments. It also pins too many things on one intelligence: planning, coding, testing, etc.

More recently, tools like Claude Code and Cline have addressed this by creating agents that integrate nicely into your codebase. They work in a horizontal fashion, where a single orchestrator intelligence manages planning, execution, and debugging in a loop, building up context as it goes. The orchestrator is powered by many tools including a team of sub-agents that they can call upon like interns.

Mycelium is an exploration into a vertical alternative. Instead of a single orchestrator that coordinates everything, Mycelium uses a multi-agent architecture where a team of intelligences work together as peers. It currently uses the following specialized roles:

• Scientist — Takes a mission and turns it into a concrete plan. Can't touch code.
• Implementer — Executes the plan. The only one who writes new code.
• Verifier — Checks if the work actually meets the goals. Can run commands and tests, can't write code.
• Maintainer — Cleans things up and writes the commit message. Refactor only.

The key idea is separation of concerns. The Scientist can't skip ahead to coding. The Verifier can't "fix" things—they can only send bugs/observations back to the Implementer. All of the plans, logs, and updates from the agents are viewable in shared artifact markdown files in your repo.

The hope is to reduce the "reasoning drift" that often happens when a single agent is given multiple tasks at once. Splitting orchestration into separate identities creates adversarial checks: for example, the Verifier isn't helping the Implementer, it's auditing them. By anchoring these nodes to a shared artifact file per mission, the system maintains a persistent source of truth, eliminating manual overhead and enabling true multi-agent autonomy.

A Demo: One Prompt to Snake Game

The game below was made in one shot. I used the Antigravity IDE with an Opus 4.5 agent call. Here's the exact prompt I gave:

Please follow .mycelium/agents/standalone/mission_organizer.md with these instructions: make a snake game in mycelium.mdx in notes content folder, don't add any writing to the notes post. make game have dark/neutral colors, an ongoing score tracker, 3 speed options that can be toggled whenever including mid game, space bar to pause, and arrow keys/WASD to move.

From that single sentence:

1. The Mission Organizer parsed the instructions and set up the mission folder.
2. The Scientist wrote a 6-step plan with clear "definition of done" criteria.
3. The Implementer built the React component and wired it into this page.
4. The Verifier found a bug (the page wasn't registered properly), sent it back.
5. The Implementer fixed it.
6. The Verifier confirmed everything worked.
7. The Maintainer cleaned up and generated the commit.

Roadmap

There's a lot to be done. The mycelium wants to grow. More nodes, more tools, more automation:

• Improved Context Management: Adding a "Historian" agent to track decisions across missions and improved state maintenance.
• Variable Model Routing: Dynamically routing tasks—cheap models for verification, reasoning models for planning, and code models for implementation.
• LangGraph: Porting the workflow to LangGraph to enable true graph-based state management and cyclic agent flows.
  • MCP: Exposing Mycelium as an MCP server so agents can access repo externally. Make agents stronger via tool use.
• Prompt Engineering: Implementing thinking protocols and few-shot tool use examples.

More details here.

---

Some More Mycelium Powered Content

Mobile-friendly^