Important
Repository relocation pending: This project will soon move to beardedeagle/agentic-coder-teams-mcp. Update your remotes, uvx --from git+... install commands, and any CI references when the move is announced.
Multi-backend MCP server for orchestrating teams of agentic coding agents.
782 tests | 94% coverage | 17 backends | Python 3.12+
opencode-claude-teams.mov
- What is this?
- Quick Start
- Installation
- Supported Backends
- MCP Tools
- MCP Prompts
- Skills
- CLI Reference
- How It Works
- Development
- Contributing
- Architecture Deep Dive
- Acknowledgments
- License
Claude Code has a built-in agent teams feature that lets multiple Claude Code instances coordinate as a team with shared task lists, inter-agent messaging, and tmux-based spawning. But the protocol is internal and tightly coupled to Claude Code's own tooling.
This MCP server reimplements that protocol as a standalone Model Context Protocol server with one major addition: pluggable backend support for 17 agentic coding CLIs. Any MCP client can use it to spawn and coordinate heterogeneous teams of coding agents across different tools and providers.
- Spawn a team of agents using different backends (Claude Code, Codex, Gemini, Aider, etc.)
- Coordinate work through shared task lists with dependency tracking
- Send messages between agents (direct, broadcast, shutdown requests)
- Monitor agent health and force-kill unresponsive agents
- Drive common lead operations with templated MCP prompts (
status_check,health_sweep,task_handoff,wrap_up,unblock_teammate) - Surface agent skills to any connected client via a bundled team-orchestration skill and per-backend skill roots
- Export traces over OTLP when the optional
[otel]extra is installed - Use any MCP-compatible client as the orchestrator
# Using uvx (recommended, no install needed)
uvx --from git+https://github.com/rlthompson-godaddy/agentic-coder-teams-mcp claude-teams serve
# Or clone and install locally
git clone https://github.com/rlthompson-godaddy/agentic-coder-teams-mcp.git
cd agentic-coder-teams-mcp
uv sync- Python 3.12+
- tmux - agents spawn in tmux panes
- At least one supported agentic CLI on your
PATH(e.g.,claude,codex,gemini) - Platform: Linux or macOS. tmux has no native Windows port; on Windows, run the server inside WSL2, Cygwin, or MSYS2. MCP clients on Windows work fine against a server running elsewhere.
claude-teams backendsThis shows which backends were auto-discovered on your system.
Add the server to your client's MCP config (see Installation below for client-specific examples).
Add to your project's .mcp.json:
{
"mcpServers": {
"claude-teams": {
"command": "uvx",
"args": ["--from", "git+https://github.com/rlthompson-godaddy/agentic-coder-teams-mcp", "claude-teams", "serve"]
}
}
}Add to ~/.config/opencode/opencode.json:
{
"mcp": {
"claude-teams": {
"type": "local",
"command": ["uvx", "--from", "git+https://github.com/rlthompson-godaddy/agentic-coder-teams-mcp", "claude-teams", "serve"],
"enabled": true
}
}
}The server speaks standard MCP over stdio. Point your client at:
uvx --from git+https://github.com/rlthompson-godaddy/agentic-coder-teams-mcp claude-teams serve
The server auto-discovers which backends are available based on binaries found on your PATH:
| Backend | CLI binary | Description |
|---|---|---|
claude-code |
claude |
Claude Code (default) |
codex |
codex |
OpenAI Codex CLI |
gemini |
gemini |
Gemini CLI |
opencode |
opencode |
OpenCode (multi-provider) |
aider |
aider |
Aider |
copilot |
copilot |
GitHub Copilot CLI |
auggie |
auggie |
Augment Code |
goose |
goose |
Goose |
qwen |
qwen |
Qwen Chat CLI |
vibe |
vibe |
Vibe |
kimi |
kimi |
Kimi CLI |
amp |
amp |
Amp |
rovodev |
rovodev |
Rovo Dev |
llxprt |
llxprt |
LLXpert |
coder |
coder |
Coder |
claudish |
claudish |
Claudish (multi-provider) |
happy |
happy |
Happy |
All backends support generic model tiers that map to backend-specific models:
| Tier | Meaning | Example mapping |
|---|---|---|
fast |
Fastest/cheapest | haiku, gpt-4o-mini |
balanced |
Default, good tradeoff | sonnet, gpt-4o |
powerful |
Most capable | opus, o3 |
You can also pass backend-specific model names directly.
Register your own backend via Python entry points using the claude_teams.backends group. See Adding a Backend for details.
Tools are organized into three tiers using progressive disclosure. At startup, only bootstrap tools are visible. Higher tiers unlock as you create teams and spawn teammates, which keeps the cold-start tool surface small.
| Tool | Description |
|---|---|
team_create |
Create a new agent team and return the lead capability for later re-attachment. One team per server session. |
team_attach |
Attach a new MCP session to an existing team using a lead or agent capability. |
team_delete |
Delete a team and all its data. Fails if teammates are still active. |
list_backends |
List all available backends and their supported models. |
list_agents |
List discoverable agent/persona profiles for a backend. Returns supported=false when the backend has no profile-selection mechanism; otherwise enumerates profiles visible from the given cwd. |
list_templates |
List registered agent templates. Templates are reusable role-context layers applied at spawn_teammate time (see Templates and Presets). |
list_presets |
List registered team presets. Presets are declarative team compositions that expand into one team_create plus one spawn_teammate per member. |
create_team_from_preset |
Expand a named preset into a team + teammates in a single call. Returns the same TeamCreateResult plus the list of SpawnResults for each member. |
read_config |
Read team configuration and member list (lead capability required). |
| Tool | Description |
|---|---|
spawn_teammate |
Spawn a coding agent via any backend. Specify backend, model, prompt, optional absolute cwd, and optional permission_mode, agent_profile, and reasoning_effort (see Agent profile and reasoning effort for backend support). |
send_message |
Send direct messages, broadcasts, or shutdown/plan-approval responses. |
read_inbox |
Read messages from an agent's inbox with pagination metadata, optional unread-only filtering, and oldest/newest ordering. |
task_create |
Create a new task with auto-incrementing ID. |
task_update |
Update task status, owner, dependencies, or metadata. |
task_list |
List team tasks in canonical task-ID order with pagination metadata. |
task_get |
Get full details of a specific task. |
| Tool | Description |
|---|---|
force_kill_teammate |
Forcibly kill a teammate's process and remove from team. |
check_teammate |
Inspect one teammate's liveness, lead-facing unread messages, unread count, and optional captured output. |
poll_inbox |
Long-poll an inbox for new messages (blocks up to 30 seconds). |
process_shutdown_approved |
Cleanly remove a teammate after graceful shutdown approval. |
health_check |
Check if a teammate's process is still running. |
Two discoverable, declarative shortcuts reduce the prompt/option plumbing a lead has to write by hand.
Agent templates are named role-context bundles applied at spawn_teammate time. A template carries a role-prompt header and optional default spawn options (backend, model, subagent type, reasoning effort, permission mode, etc.). Pass options.template = "<name>" to apply one. Task prompts layer on top of the role prompt; explicit SpawnOptions fields always override template defaults.
Seeded built-ins:
| Template | Role | Default subagent |
|---|---|---|
code-reviewer |
Reviews code; rates findings by severity; does not rewrite. | code-reviewer |
debugger |
Reproduces failures; hypothesis-driven root-cause analysis. | debugger |
executor |
Implements focused tasks; runs lint and tests before declaring done. | executor |
test-engineer |
Writes and hardens tests; covers happy path, boundaries, and errors. | test-engineer |
writer |
Produces and refines technical documentation. | writer |
Team presets are declarative team compositions: one preset name expands into a team_create followed by one spawn_teammate per member. Expansion is not transactional — if a mid-fan-out spawn fails, the team and prior members persist and the caller can either retry the remaining members via spawn_teammate or tear down via team_delete.
Seeded built-ins:
| Preset | Purpose | Members |
|---|---|---|
review-and-fix |
Review a change and produce the fix. | reviewer (code-reviewer) + executor (executor) |
docs-pair |
Docs pair: writer drafts, reviewer hardens. | writer (writer) + reviewer (code-reviewer) |
Example — spawn a teammate with a template applied:
{
"tool": "spawn_teammate",
"arguments": {
"team_name": "my-team",
"name": "reviewer",
"prompt": "Review PR #42.",
"options": {"template": "code-reviewer"}
}
}Example — expand a preset into a full team:
{
"tool": "create_team_from_preset",
"arguments": {
"preset_name": "review-and-fix",
"team_name": "fix-pr-42",
"description": "Review + fix PR #42."
}
}Plugin-provided templates and presets register through the same module-level registries and can supersede built-ins by registering with the same name. The schemas also carry forward-compat metadata (skill_roots, mcp_servers) reserved for per-team skill and MCP-server injection; the spawn path ignores those fields today but the shape is stable.
team_createreturns alead_capability. Keep it if you want to attach another MCP session to the same team later.spawn_teammateissues a per-agent capability and includesteam_attach(...)instructions in the worker's bootstrap prompt.- A session attached with the lead capability can perform all lead actions.
- A session attached with an agent capability can perform agent-scoped actions as that agent, but cannot use lead-only tools such as
broadcast,force_kill_teammate,check_teammate, orhealth_check.
spawn_teammateacceptspermission_modewith three values:default: preserve the backend's normal automation behaviorrequire_approval: strip backend auto-approval flags when supportedbypass: require an explicit approval-bypass mode; unsupported backends reject the spawn
- You can also set
CLAUDE_TEAMS_PERMISSION_MODEto change the server-wide default whenpermission_modeis omitted. - Backends vary in how they implement it.
claude-codeuses--permission-mode bypassPermissions; one-shot CLIs such ascodex,coder,gemini,aider,amp,copilot,happy,llxprt,qwen,rovodev, andclaudishuse their backend-native bypass flags.
spawn_teammate accepts two optional backend-specific tuning fields. Both are validated server-side and rejected with a clear error when the resolved backend does not expose the relevant mechanism, so cross-backend code paths stay safe.
agent_profile — named persona / recipe selection. Discover what's available with list_agents(backend_name, cwd); the response reports supported=false when the backend has no profile mechanism, otherwise returns discovered profile names and their on-disk paths.
| Backend | Flag | Source of profiles |
|---|---|---|
claude-code |
--agent <name> |
.claude/agents/*.md under project and user home |
claudish |
--agent <name> |
.claude/agents/*.md (same Claude-style layout) |
codex |
-c 'agents.<name>.config_file="<path>"' |
[agents.*] tables in ~/.codex/config.toml and project config |
coder |
-c 'agents.<name>.config_file="<path>"' |
[agents.*] tables in ~/.coder/config.toml and project config |
goose |
--recipe <path> |
Recipe files on $GOOSE_RECIPE_PATH |
Other backends reject agent_profile with AgentSelectUnsupportedToolError. Unknown names (even on supported backends) are rejected with UnknownAgentProfileToolError.
reasoning_effort — effort-ladder selection. Options are backend-specific; pass a value from the backend's option set below.
| Backend | Flag | Options | Notes |
|---|---|---|---|
claude-code |
--effort <value> |
low, medium, high, max |
Dedicated dial; independent of model. |
codex |
-c model_reasoning_effort=<value> |
low, medium, high, xhigh |
Dedicated dial. |
coder |
-c model_reasoning_effort=<value> |
low, medium, high, xhigh |
Dedicated dial. |
kimi |
-m <variant> |
kimi-k2, kimi-k2-thinking, kimi-k2-thinking-turbo |
Overrides model: on Kimi, the thinking variants are the effort ladder. |
amp |
-m <mode> |
free, rush, smart |
Overrides model: Amp's agent modes combine effort, model, and tool selection. |
Other backends reject reasoning_effort with ReasoningEffortUnsupportedToolError. Values outside the backend's option set are rejected with InvalidReasoningEffortToolError.
task_listandread_inboxnow return paginated envelopes with:itemstotal_countlimitoffsethas_morenext_offset
task_listkeeps its canonical task-ID ordering.read_inboxkeepsorder="oldest"by default and also acceptsorder="newest"so recent mail can be fetched from page 1.- This avoids unbounded MCP payloads without truncating message or task content.
Example read_inbox response:
{
"items": [
{
"from": "team-lead",
"text": "Please review task 7",
"timestamp": "2026-04-07T18:22:11.531Z",
"read": false,
"summary": "review request"
}
],
"totalCount": 1,
"limit": 100,
"offset": 0,
"hasMore": false
}- Set
CLAUDE_TEAMS_ENCRYPTION_MASTER_KEYto enable inbox-at-rest encryption. - The server derives a per-team inbox key from that master key and encrypts inbox entries on disk.
- Existing plaintext inbox entries remain readable; they are opportunistically rewritten encrypted on the next modifying inbox operation.
- If encrypted inbox entries exist and the master key is missing or wrong, inbox reads fail closed.
Templated prompts let clients drive common team-lead operations without
re-writing orchestration instructions each time. All prompts are tagged
team, so they become visible alongside team-tier tools after
team_create or team_attach via the same progressive-disclosure
mechanism.
| Prompt | Description | Arguments |
|---|---|---|
status_check |
Check a teammate's health, current task, and blockers. | team, teammate |
health_sweep |
Run health check across all teammates and flag issues. | team |
task_handoff |
Hand off completed work from one teammate to another. | team, from_teammate, to_teammate, optional context |
wrap_up |
Collect all task results and prepare a team summary. | team |
unblock_teammate |
Send a targeted message to unblock a stuck teammate. | team, teammate, optional hint |
Each prompt returns an assistant-prefilled conversation that skips preamble and drives the model straight into the supporting tool calls.
The server acts as a skill provider for connected clients, surfacing agentic-skills content alongside its tools.
The server ships with team-orchestration/SKILL.md, a complete guide to
leading a team through this MCP server: lifecycle, delegation patterns,
coordination, monitoring, and teardown. It is served to any client that
supports agent skills.
Beyond FastMCP's built-in providers for Claude, Codex, Copilot, Cursor,
Gemini, Goose, OpenCode, and VSCode, this server registers nine
additional SkillsDirectoryProviders covering the remaining backends in
the registry:
| Backend | Skill roots (in lookup order) |
|---|---|
amp |
~/.config/amp/skills/, ~/.config/agents/skills/, ~/.claude/skills/ |
auggie |
~/.augment/skills/, ~/.claude/skills/, ~/.agents/skills/ |
coder |
~/.code/skills/, ~/.codex/skills/ |
goose |
~/.agents/skills/, ~/.goose/skills/, ~/.claude/skills/ |
kimi |
~/.kimi/skills/, ~/.claude/skills/, ~/.codex/skills/, ~/.config/agents/skills/, ~/.agents/skills/ |
llxprt |
~/.llxprt/skills/ |
qwen |
~/.qwen/skills/ |
rovodev |
~/.rovodev/skills/ |
vibe |
~/.vibe/skills/ |
Earlier roots win on name collision. The goose override exists because
FastMCP's built-in GooseSkillsProvider points at a path Block Goose
does not actually use.
The claude-teams CLI provides terminal commands for inspecting and managing teams. The CLI and MCP server can run concurrently -- they share the same file-based state with fcntl.flock() guards.
claude-teams serve # Start the MCP server
claude-teams backends # List available backends
claude-teams templates # List registered agent templates
claude-teams presets # List registered team presets
claude-teams config TEAM # Show team config
claude-teams status TEAM # Show member status and task summary
claude-teams inbox TEAM AGENT # Read an agent's inbox messages
claude-teams health TEAM AGENT # Health-check a teammate's process
claude-teams kill TEAM AGENT # Force-kill a teammate
All commands support --json / -j for machine-readable output.
# List what backends are available on your system
claude-teams backends
# Discover reusable role-context templates and declarative team presets
claude-teams templates
claude-teams presets
# Show team config with member list
claude-teams config my-team
# Check if all agents are still running
claude-teams health my-team worker-1
# Read the team lead inbox in newest-first order
claude-teams inbox my-team team-lead --order newest
# Force-kill an unresponsive agent
claude-teams kill my-team stuck-workerTeammates launch as separate processes in tmux panes via tmux split-window. Each agent gets:
- A unique agent ID (
name@team) - An assigned color from a rotating palette
- Backend-specific CLI flags and environment variables
- Its initial prompt delivered to its inbox
JSON-based inboxes stored under ~/.claude/teams/<team>/inboxes/. File locking via fcntl.flock() prevents corruption from concurrent reads and writes. Message types:
- Direct messages -- one-to-one communication between agents
- Broadcasts -- send to all teammates at once
- Shutdown requests/responses -- graceful shutdown protocol
- Plan approval -- request and grant plan approval
JSON task files stored under ~/.claude/tasks/<team>/. Tasks support:
- Status progression:
pending->in_progress->completed - Ownership assignment to specific agents
- Dependency graphs (
blocks/blockedBy) with cycle detection - Arbitrary metadata
- Auto-incrementing IDs
~/.claude/
├── teams/<team-name>/
│ ├── config.json # Team config + member list
│ ├── inboxes/
│ │ ├── team-lead.json # Lead agent inbox
│ │ ├── worker-1.json # Teammate inboxes
│ │ └── .lock
│ └── runs/ # One-shot backend result files (auto-cleaned)
└── tasks/<team-name>/
├── 1.json # Task files (auto-incrementing IDs)
├── 2.json
└── .lock
| Operation | Safety mechanism |
|---|---|
| Config writes | Atomic via tempfile.mkstemp() + os.replace() to prevent partial reads |
| Inbox operations | Guarded by fcntl.flock() file locks |
| Task operations | Guarded by fcntl.flock() file locks with validation-then-write phasing |
The server uses FastMCP's tag-based visibility system to progressively reveal tools and prompts as state evolves:
- Cold start -- only 5 bootstrap tools visible; team-tagged prompts hidden
- After
team_create-- 7 team-tier tools and 5 team-tagged prompts become visible - After first
spawn_teammate-- 5 teammate-tier tools become visible - After
team_delete-- resets back to bootstrap-only
This is transparent to MCP clients -- the server sends ToolListChangedNotification automatically.
git clone https://github.com/rlthompson-godaddy/agentic-coder-teams-mcp.git
cd agentic-coder-teams-mcp
uv syncuv run pytest # Run all tests
uv run pytest --cov=claude_teams # With coverage
uv run pytest tests/test_server_bootstrap.py -v # Single module
uv run pytest -k "test_spawn" # Filter by nameuv run ruff format # Format
uv run ruff check # Lint
uv run ty check # Type check (Astral's ty)OpenTelemetry tracing is optional. Install the extra and set the usual OTel environment variables — FastMCP emits server spans for every tool, prompt, and resource invocation once a tracer provider is registered.
uv sync --extra otel
# Or with pip
pip install 'claude-teams[otel]'Configuration (standard OTel environment variables):
| Variable | Purpose | Default |
|---|---|---|
OTEL_SERVICE_NAME |
Service name stamped on every span | claude-teams |
OTEL_EXPORTER_OTLP_ENDPOINT |
OTLP/HTTP collector endpoint | unset (no export) |
OTEL_EXPORTER_OTLP_HEADERS |
Auth headers for the collector | unset |
OTEL_SDK_DISABLED |
Set to true/1 to disable without uninstalling |
unset |
If the otel extra is not installed, telemetry setup is a silent no-op
and the server runs normally.
src/claude_teams/
├── server.py # Thin MCP assembly surface and entrypoint
├── server_runtime.py # Shared MCP app, auth, pagination, annotations, lifecycle
├── server_schema.py # Reusable validated parameter types for tools/prompts
├── server_bootstrap.py # Bootstrap-tier tool registration
├── server_team_spawn.py # Team-tier spawn and message tools
├── server_team_tasks.py # Team-tier task and inbox tools
├── server_team_relay.py # One-shot backend relay helpers
├── server_teammate.py # Teammate-tier tool registration
├── server_prompts.py # Team-tier MCP prompt templates
├── skill_providers.py # Custom SkillsDirectoryProvider table for non-default backends
├── telemetry.py # Optional OpenTelemetry tracer-provider setup
├── errors.py # Central exception taxonomy
├── cli.py # Typer CLI commands
├── async_utils.py # Thread offload helper for blocking local operations
├── models.py # Pydantic models (TeamConfig, Task, InboxMessage, etc.)
├── teams.py # Team CRUD (config read/write, member management)
├── tasks.py # Task CRUD (create, update, list, dependencies)
├── messaging.py # Inbox operations (read, write, structured messages)
├── capabilities.py # Lead/agent capability storage and resolution
├── inbox_crypto.py # Optional inbox-at-rest encryption helpers
├── filelock.py # Shared fcntl-based file locking
├── skills/
│ └── team-orchestration/SKILL.md # Bundled team-orchestration skill
└── backends/
├── base.py # Compatibility re-exports for backend contracts/base
├── contracts.py # Backend protocol and spawn result/request types
├── tmux_base.py # Shared tmux-backed BaseBackend implementation
├── registry.py # Auto-discovery and registration
├── claude_code.py # Claude Code backend
├── codex.py # OpenAI Codex backend
├── gemini.py # Gemini CLI backend
└── ... # 14 more backend implementations
- Create
src/claude_teams/backends/your_backend.pyinheriting fromBaseBackend - Implement these methods:
build_command(request) -> list[str]-- CLI args to spawn the agentbuild_env(request) -> dict[str, str]-- extra environment variablessupported_models() -> list[str]-- available model namesdefault_model() -> str-- default model when none specifiedresolve_model(model) -> str-- map generic tiers to backend-specific names- optionally
default_permission_args() -> list[str]when the backend normally auto-approves - optionally
bypass_permission_args() -> list[str]when explicit bypass differs from the default
- Set class attributes:
name,binary_name - Add the entry to
_BUILTIN_BACKENDSinregistry.py - Add tests in
tests/test_backends/test_your_backend.py
Example backend (minimal):
from claude_teams.backends.base import BaseBackend, SpawnRequest
class MyBackend(BaseBackend):
_name = "my-tool"
_binary_name = "mytool"
def supported_models(self) -> list[str]:
return ["default", "large"]
def default_model(self) -> str:
return "default"
def resolve_model(self, model: str) -> str:
return {"fast": "default", "balanced": "default", "powerful": "large"}.get(model, model)
def build_command(self, request: SpawnRequest) -> list[str]:
return [self.binary_name, "--model", request.model, "--prompt", request.prompt]
# build_env is inherited from BaseBackend and returns {} by default.
# Override only when your backend needs to export custom env vars.Or register externally via the claude_teams.backends entry point group in your package's pyproject.toml:
[project.entry-points."claude_teams.backends"]
my-tool = "my_package.backend:MyBackend"- Format with
ruff format, lint withruff check - Type check with
ty check - All tool functions include docstrings (behavioral description only -- FastMCP generates parameter docs from type annotations)
- Tests use
pytestwithpytest-asyncioin auto mode
- Fork the repo and create a feature branch
- Add tests for new functionality
- Ensure all tests pass:
uv run pytest - Ensure coverage stays above 90%:
uv run pytest --cov=claude_teams - Format and lint:
uv run ruff format && uv run ruff check
Click to expand -- detailed technical architecture for engineers
Backends implement a Backend protocol providing:
- Lifecycle:
spawn,health_check,kill,graceful_shutdown - Interactivity:
capture,send,wait_idle,execute_in_pane - Model resolution: Map generic tiers (
fast,balanced,powerful) to backend-specific model IDs
A BaseBackend class provides shared tmux lifecycle management via claude-code-tools. Concrete backends only need to implement build_command, build_env, and model resolution.
The server is built on FastMCP 3.x using:
- Lifespan management --
_LifespanStatetracks registry, session ID, active team, and teammate state - Tag-based tool visibility -- tools tagged as
bootstrap,team, orteammatewith per-session enable/disable - Automatic
ToolListChangedNotification-- clients are notified when the visible tool set changes
Messages follow a structured format. The send_message tool supports five message types:
| Type | Purpose | Required fields |
|---|---|---|
message |
Direct message between team members | recipient, content, summary |
broadcast |
Send from team-lead to all teammates |
content, summary |
shutdown_request |
Ask agent to stop | recipient |
shutdown_response |
Reply to shutdown | sender, request_id, approve |
plan_approval_response |
Approve/reject plan | recipient, request_id, approve |
For message, sender defaults to team-lead; teammates should pass their own
agent name explicitly when sending direct messages. broadcast remains
lead-only. Sessions attached with a worker capability may send direct
messages only as that worker unless a lead capability is used.
pending ──> in_progress ──> completed
│
└──> deleted (removes file)
Transitions are validated -- you cannot go backwards (e.g., in_progress -> pending is rejected). Dependency cycles are detected and rejected on creation.
- One team per server session (enforced in
team_create) - Team names must match
[a-zA-Z0-9_-]+and be at most 64 characters - Agent names follow the same rules and
team-leadis reserved - The
has_teammatesflag prevents redundantenable_componentscalls on subsequent spawns
This project stands on the shoulders of giants. The original implementation and protocol reverse-engineering was done by Victor in claude-code-teams-mcp, based on his deep dive into Claude Code's internals. His work cracking open the agent teams protocol and building the first standalone MCP server for it made everything here possible. Thank you, Victor.