Mycelium connects your team's planning to your agents' execution — a shared canvas they both read from, a codebase graph they both navigate, and a history that captures everything.
npx @kopikocappu/mycelium init
The roadmap canvas is where humans decide what gets built — features, dependencies, priorities, critical path. Your agents can read it all through the same MCP server. They know what's planned before you assign anything.
Before touching a file, your agent calls /preflight and gets back exactly which files to read. When it's done, it marks the feature complete on the canvas. The loop closes automatically.
Every file touched, every session logged, every change attributed — to a human, Claude Code, Cursor, or any agent. The canvas updates. The history fills in. Nothing your agents do is invisible.
Draw your features. Set dependencies. Find your critical path. Your agents read the exact same canvas through the MCP server — they know what's ready to build, what's blocked, and what to work on next. When they're done, they mark it complete. You see it instantly.
This isn't a project management tool bolted on. It's the shared source of truth between you and your AI agents.
GET /roadmap and mark features done via PATCH.Describe any task in plain English. Get back exactly the files that matter, scored by relevance, with AI-written descriptions. Four files instead of forty, every time.
Find files by concept, not keyword. "Authentication flow" surfaces the right files even when none of them have the word "auth" in their name. The graph understands what code means.
Before modifying a function, ask what calls it. Get the full blast radius — every file and function that depends on what's about to change, so nothing breaks unexpectedly.
Every file as a node, every import as an edge, every function call relationship visible. Open it in any browser. Understand any codebase in five minutes with AI descriptions on every node.
Every session logged. Every file touched, attributed to a human or a specific AI agent, grouped by task. AI-powered summaries of what each session accomplished. Full audit trail.
Mycelium writes CLAUDE.md and .mcp.json into your project automatically. Agents discover it and connect without manual configuration.
Your team draws the plan on the canvas. Your agent checks what's ready, calls preflight to get the right files, does the work, and marks it done. Your team sees the canvas update and the history fill in. All local. All yours.
Mycelium parses every file, resolves every import, and builds a full dependency graph. Claude Haiku writes a plain English description of every file. Done in minutes. Stays current automatically.
Your browser opens the roadmap canvas. Draw your features, set dependencies, find your critical path. Your agents connect to the same MCP server and can read everything you've planned.
Your agent reads the plan, calls preflight, works on the right files, marks features complete. You watch the canvas update and the history fill in — with full attribution on every change.
Stop watching Claude Code open 30 files before writing a line. Mycelium gives it a map and a plan. Focused agents ship faster and break less.
Set the roadmap, define priorities, find the critical path. Then watch your agents execute — with full session attribution and a change history that never lies.
Open the graph viewer. Every file, every dependency, every connection — with plain English on every node. The fastest onboarding tool you didn't know you needed.
Mycelium works for a solo developer exploring a codebase, an AI agent navigating it autonomously, and a team running both together. Pick the one that fits where you are today.
Run one command. Open a browser. Your entire codebase is mapped as a force-directed graph — files as nodes, imports as edges. Click any file for an AI description of what it does. Search by concept instead of filename. Understand how things connect before you touch anything.
mycelium init once to scan and describe every file
Your agent connects to Mycelium's MCP server and calls preflight before touching anything. It gets exactly the files it needs — scored, described, connected. It checks dependencies before modifying a function. It moves fast because it actually knows where it's going.
/preflight?task= before writing a single line — 4 files, not 40
/dependencies?file= to understand what a file imports and what imports it
/xref?file=&fn= to find every caller of a function before modifying it
You draw features on the canvas, set dependencies, find the critical path. Your agent reads that exact canvas through the MCP server and knows what to build next. When it's done, it marks the feature complete. You see the node turn green. The History tab fills in. Nothing is invisible.
/roadmap — sees what's active, what's blocked, what's ready to build
PATCHes the feature to complete