The coordination gap
AI agents make individual developers faster. But teams aren't just N individuals. They carry coordination overhead that AI doesn't address:
- Two developers on the same codebase; their AI sessions don't share discoveries.
- A decision inside one Claude Code session ("we chose Postgres over MySQL because…") is invisible to the rest of the team's agents.
- Handoffs lose months of AI context.
- Standups, Slack threads, PR comments, Linear tickets—all outside the AI's view.
Existing approaches have gaps:
- Notion / Confluence / Linear: humans write, humans read. AI adds summaries, not shared structured state.
- Slack / Discord MCP: Claude can read channels, but chat isn't the right shape for "what did we decide about auth last Tuesday?"
- Cursor Teams: shared rules, team-pushed commands, per-repo memories. IDE-locked.
- Sourcegraph Cody Enterprise ($59/u/mo): codebase context and shared prompts. Code search, not decision tracking.
- GitHub Copilot Enterprise: org context. No agent-queryable decision store.
Custom MCP as team state
The pattern emerging is custom MCP servers as team state: a shared backend every agent can read from and write to, via the same protocol they already use. DebugBase did this for error/fix pairs—one agent's fix becomes everyone's. We built the same idea for Claude Code.
Our Coordination MCP
The Coordination MCP is a separate VibeCoded product (repo: hotak92/vct-coordination). It is a Claude Code MCP server backed by a shared Supabase project. Every team member runs the MCP locally; all of them point at the same Postgres. Decisions live in human_decisions, messages in vct_channel_messages (V2 schema), shared knowledge in shared_knowledge. The V2 channel-push schema makes the MCP fakechat-compatible: new messages arrive as <channel source="vct-coordination"> events directly inside the Claude turn, no polling.
The tool surface, condensed:
send_message/reply_channel— direct or broadcast team messaging.ask_human— block an agent waiting on a human decision;answer_decisionresolves it;check_decisionqueries it later.get_team_status— see who is online; agents can defer heavy decisions to humans.sync_work_items— share task progress across teammates.sync_knowledge/get_knowledge— push and pull KG nodes across machines. Agent on Martino's machine creates a node, Fabio's MCP can pull it.post_idea/report_bug— ideation and bug capture without leaving the session.
Decision tracking: ask_human blocks the agent. A teammate answers via answer_decision. Months later, check_decision recovers the rationale. This is the queryable decision store every other tool lacks.
Knowledge sync: sync_knowledge writes a KG node with embeddings; get_knowledge retrieves via semantic search. Combined with the local weaviate-kg MCP, agents get personal and team knowledge in one call.
VCT Launcher: the visual surface
All of the above is exposed through a dedicated coordination tab in the VCT Launcher — the desktop app that ships alongside the Coordination MCP:
- Shared decisions list — every
ask_humanyour team's agents have raised, with their current status and the resolved rationale. - Team member online status — pulled live from
get_team_status; you see who is in session before assigning work. - Pending items requiring your input —
ask_humanblocks waiting for you surface as desktop notifications and appear in a dedicated queue inside the launcher. - Knowledge sync log — a feed of
sync_knowledgeevents so you can see what new shared nodes agents pushed since your last session.
Team-pushed skill packs. An admin can push a curated .claude/skills/ collection directly from the launcher. All team members' Claude Code installations sync the pack via the Coordination MCP's sync_knowledge channel — no manual file distribution. This works whether team members run the free Orchestrator, Pro, or MAO.
Per-repo memories. Each project is bound to its own KG_COLLECTION (Weaviate collection name) in the launcher UI. Switching projects in Claude Code automatically routes all KG queries to the right collection. No cross-contamination, no manual configuration per session.
Pricing, honestly
- Self-host, free. Run your own Supabase project, point the MCP at it. AGPL-3.0. Repo at
hotak92/vct-coordination. - Managed, pricing TBD. VibeCoded-hosted Supabase, multi-tenant with row-level security. Not live yet — we would rather say that than ship a fake landing page.
How it compares
| Tool | AI-queryable? | Decision tracking | Self-host | MCP-native | Pricing |
|---|---|---|---|---|---|
| VibeCoded Coordination MCP | Yes | Yes (ask_human + knowledge sync) | Yes | Yes | Free self-host / managed TBD |
| Cursor Teams | Yes (in Cursor) | Rules + Memories | No | Partial | Paid seats |
| Sourcegraph Cody Enterprise | Yes (code) | No | Yes | No (proprietary) | $59/u/mo |
| GitHub Copilot Enterprise | Code-search context | No | No | No | $39/u/mo |
| Slack-MCP (community) | Chat only | No | Yes | Yes | Free |
| Notion / Linear AI | Weak | Manual / issues only | No | No | Paid seats |
Cursor Teams is solid for teams living entirely in Cursor. We deliver the same primitives via MCP, so team workspace, shared rules, per-repo memories, and decision tracking work with any Claude Code workflow—free Orchestrator, Pro, MAO, or custom setups. The Coordination MCP is the backend; the VCT Launcher is the UI. Both ship by default.
Where to go next
Coordination MCP works on top of the free Orchestrator, VibeCoded Pro, or MAO — same protocol. Setup, the live tool list, and self-host instructions live at /products/coordination-mcp. For the underlying protocol, see the companion MCP post.
Sources: