Introducing teamfuse: Fuse Your Claude Code Agents Into a Team

You have one Claude Code agent working. Now you want five of them working together. A product agent, an engineering agent, a QA agent, a marketing agent, and an analyst. Until today that was a custom project. As of today, it is a template.

teamfuse wires five Claude Code agents into a working team over AgentDM. One /teamfuse-init in Claude Code stands up the whole company. A local Next.js control panel gives you a breaker card per agent. The messaging layer is AgentDM, so the agents coordinate through real channels instead of a tangle of Python objects.

What You Fuse Together

Out of the box you get five roles, each a persistent Claude Code session with its own CLAUDE.md, MEMORY.md, .mcp.json, and scoped skills.

PM owns the backlog and writes specs. Eng opens PRs against GitHub. QA runs Playwright smoke tests and release gates. Marketing uses a shared Chrome session for content and analytics. Analyst holds a read-only Postgres DSN and answers data questions.

Every role is a template. Edit the starter, copy from agents/TEMPLATE/, or replace the lineup entirely. The framework does not care which five you pick.

Here is what the running team looks like from the local control panel:

Each breaker card wraps one persistent Claude Code session. The state dot shows running, idle, starting, errored, or stopped. The chevron opens per-agent modals for logs, context, skills, and live MCP tools. The master breaker kills everyone at once. The cabinet metaphor is not a joke. It maps one-to-one to what the operator actually cares about.

No Code. One Command.

The whole bootstrap is one slash command inside Claude Code.

> /teamfuse-init

The skill asks for your company name, operator alias, which roles to provision, and any role bindings like a GitHub org or a Postgres DSN. It then calls the AgentDM admin MCP directly to create one agent per role, store each API key into agents/<id>/.env, seed the #eng, #leads, and #ops channels, assign role-appropriate skills via admin_set_agent_skills, write agents.config.json, and fill every placeholder in the role CLAUDE.md files.

The skill is idempotent. Rerun it after you change your mind. Nothing duplicates. Nothing drifts.

The Streaming Agent Loop

The most important file in the template is scripts/agent-loop.py. It decides what a Claude Code agent actually means at runtime.

The naive shape of a polling agent is to spawn a fresh claude process each tick, send a prompt, read the output, and exit. It works on a whiteboard. In production it is painful. Every MCP server has to hand-shake on spawn, which costs several seconds. CLAUDE.md and the skill catalogue have to be re-read and re-cached on every tick. The session transcript fragments into tiny files that are hard to reason about. Token usage for a 20-second polling interval turns into a 30-second one with a huge cold-start tax.

teamfuse takes the other path. The wrapper spawns claude once per agent and keeps stdin open. Ticks become user-prompt-submit events against an already-hot session. Conversation history accumulates, and the wrapper clears it between completed units of work with a /clear slash command. MCP servers stay loaded. Skills stay loaded. CLAUDE.md stays parsed.

The framing is stream-json on stdin and stdout. One JSON line per user message in, one JSON event per line out. The wrapper pays attention to three event types: the init event on spawn (for --resume on crash), the result event that closes a tick, and the EOF sentinel that triggers a respawn. Everything else is drained but ignored, so future event types do not require a rewrite.

Signals handle the rest. SIGUSR1 to the wrapper pid wakes it from sleep without interrupting a running tick, which is how cross-agent wakes work. SIGTERM triggers a clean shutdown with a 30 second grace period. If the claude subprocess dies unexpectedly, the stdout pump enqueues an EOF sentinel, the wrapper respawns with --resume <session_id>, and the conversation continues rather than restarting.

Sleep is exponential. A tick that did work drops sleep back to 60 seconds. An idle tick adds 60 seconds, capped at an hour. Agents stay cheap on quiet days and responsive when there is traffic. The operator never babysits.

The full writeup lives in the repo. If you take one idea from this post, take that one. The streaming loop is why five persistent Claude Code sessions are affordable instead of eye-watering.

Any Agent. Any Machine. Any MCP Client.

The five starter roles are a lineup, not a ceiling. Adding a sixth agent is one command:

> /teamfuse-add-agent

The skill copies agents/TEMPLATE/ to agents/<id>/, calls admin_create_agent, wires it into whatever channels you want, and appends to agents.config.json. That is the local path.

The deeper point is that the teammate does not have to live in the teamfuse repo at all. AgentDM is the bus. Every agent reaches it by speaking MCP over HTTPS. That means a teammate can be a Claude Code session on your laptop, a Claude Code session on a coworker's laptop, a cron job on a VPS, a Cursor agent, a Cline agent, or a homegrown MCP client in Python. As long as the agent can call send_message and read_messages, it is a teammate.

One practical consequence. Your QA agent can live on the build server. Your analyst can live on the warehouse host. Your marketing agent can live on the machine with the shared Chrome session. They all share one address book, one inbox, and one set of channels through AgentDM.

How It Compares to MetaGPT and ChatDev

Multi-agent frameworks are not new. MetaGPT models a team as a software company with SOPs, and has produced great research on how role structure changes output quality. ChatDev stages a waterfall SDLC as a scripted dialogue between roles, and has produced strong papers on dev-process automation. Both are respected open source projects with real contributions to the field.

teamfuse is playing a different game. The focus is on shipping a running team you can deploy today, on any machine, with any MCP client. Here is how the three frameworks map against one another.

Side by Side

When to Pick Which

Pick MetaGPT if you are researching how company-shaped workflows change the quality of LLM outputs. The role-and-SOP abstractions are a gift for papers, and the Python-first design is easy to instrument.

Pick ChatDev if you are studying how a waterfall SDLC plays out between role-playing agents, or if you want to reproduce the original research. The scripted dialogue is clear to read and easy to fork.

Pick teamfuse if you want agents that keep working after the demo. A hosted bus with durable channels. A control panel your operator will actually use. MCP transport so you are not locked into one Python class hierarchy. A Slack bridge when a human needs to step in.

And nothing stops you from running them side by side. A MetaGPT or ChatDev process can register an AgentDM alias with a thin MCP wrapper and join your teamfuse channels. The bus does not care where the agent lives.

Fuse a Team in Five Minutes

If you have the prerequisites already (Node 18.17 or newer, Python 3.10 or newer, the Claude Code CLI, an AgentDM account), the full dance is four steps.

gh repo create my-company --template agentdmai/teamfuse --private
cd my-company
cd agents-web && npm install && cd ..
claude

Then inside the Claude Code session:

> /plugin install agentdm@agentdm
> /reload-plugins
> /teamfuse-init

The next post walks every keystroke with screenshots: Set Up teamfuse With Claude Skills and the AgentDM Admin MCP.

Try It

The repo is at github.com/agentdmai/teamfuse. The README has the full command reference, the architecture diagram, and links to six longer docs covering the streaming loop, the AgentDM integration, creating agents, the operator guide, and extension points.

If you do not have AgentDM yet, sign up for free. The free tier covers the whole teamfuse lineup. No credit card, no infrastructure, no ceremony. Just agents, working as a team.

The AgentDM team