DreamTeam

English · Русский

A self-organizing swarm of AI agents with no leader. You give the swarm a goal; agents with human names
plan it on a shared task board, claim tasks, review each other's work, talk in task threads and direct
messages, share a git workspace, set themselves triggers and write their own tools as MCP servers.
The swarm itself is an MCP server, so Claude Code can watch it, steer it, or join it as a member.

uv tool install git+https://github.com/VictorAboba/DreamTeam.git
dreamteam "Build a snake game in Python with tests"

What makes it different

• No orchestrator. Setting a goal puts a planning task on the board; whoever is free takes it, the others
  pick up tasks as they appear. Claiming is atomic, dependencies block, and every task is accepted by a
  different member (independent review) — or by you, if nobody else is left.
• Agents build their own tools. The built-in tool set is small: the board, messages, files, a console and
  triggers. Anything else an agent writes as an MCP server (mcp_create); it is checked, registered for
  itself, its task or the whole swarm, and kept in a library for later runs.
• The swarm is an MCP server. Connect Claude Code (or any MCP client) to act as the user — set goals, read the
  board, approve reviews — or call join_swarm and work inside the swarm as a teammate.
• Every step is traceable. Each time an agent wakes up becomes a trace: every LLM call with its thinking,
  tool calls, tokens (including cache), cost, latency and the exact request context, even after the history was
  compacted. Browse it on the board, in the terminal or over MCP, export it as JSON.
• Any model. Claude, OpenAI, OpenRouter, Ollama, vLLM, LM Studio or any OpenAI-compatible endpoint, with a
  different model per agent or role, token and dollar accounting per agent, and a budget that pauses the swarm.
• Built to run unattended. Everything is in one SQLite file per session; after a restart the swarm continues
  where it stopped. Long commands become background jobs instead of being killed, sessions can run without
  network for benchmarks, and the whole swarm can run in a Docker sandbox.

Interfaces

Install

You need Python 3.11+, uv and git.

uv tool install git+https://github.com/VictorAboba/DreamTeam.git

This puts the dreamteam command on your PATH (run uv tool update-shell if it isn't found). To hack on it,
clone the repository and run uv tool install --editable . instead — see CONTRIBUTING.md
and Install and quick start.

Quick start

export ANTHROPIC_API_KEY=sk-ant-...        # or configure any provider in Settings
dreamteam                                   # terminal UI; the web board is served too
dreamteam "Build a CLI that converts CSV to JSON, with tests"   # start a session with this goal
dreamteam serve                             # web board only

1. Open Settings → Models and endpoints on http://127.0.0.1:8765, pick a provider and model, give the key
   (an environment variable name or the key itself) and press Check.
2. On Sessions, press Start a new session and describe the goal: the first line becomes the title, the rest the
   description. You can also pick the starting team, e.g. --team "architect, developer*2, tester".
3. Watch the swarm plan and work; write to any agent with @Name, review tasks it hands you with
   /approve 3 or /reject 3 what to fix. All commands and keys: Terminal UI and console.

Agent prompts are in English or Russian: set language = "en" under [swarm] in ~/DreamTeam/dreamteam.toml
or in the new-session dialog.

Point a session at an existing project instead of its own folder — agents then commit to your current branch:

git switch -c dreamteam/billing
dreamteam --workspace ~/code/my-app "Cover the billing module with tests"

The rules that keep your own work safe are in Session folder and an existing project.

Connect Claude Code

claude mcp add --transport http dreamteam http://127.0.0.1:8765/mcp   # to a running server
claude mcp add dreamteam -- dreamteam mcp                               # or let Claude Code start it

Claude Code then acts as the user of the swarm, or joins it with join_swarm — see
Connecting Claude Code.

Run in Docker

dreamteam sandbox ~/DreamTeam --goal "..."

Agents' commands and their MCP servers then run inside the container. Add --network off to cut them off
from the internet (strict in Docker and on Linux) — see Docker sandbox and sessions without network.

Configuration

Settings live in ~/DreamTeam/dreamteam.toml and are easiest to change on the Settings page.
A minimal example:

[swarm]
language = "en"
start_agents = 3
max_agents = 8
max_cost_usd = 5.0

[models.default]
provider = "anthropic"
model = "claude-opus-5-5"
api_key_env = "ANTHROPIC_API_KEY"

[models.local]            # Ollama, vLLM, OpenRouter — any OpenAI-compatible API
provider = "openai"
base_url = "http://localhost:11434/v1"
model = "qwen3:32b"
api_key = "ollama"

Every section and key: Configuration.

Security

Agents run commands and MCP server code with your user's rights. For untrusted goals use
dreamteam sandbox. API keys and other secrets from the environment are not passed to agents' commands.
The server listens on 127.0.0.1 and has no authentication: don't expose it without a reverse proxy that adds
one. Details: Security; to report a vulnerability, see SECURITY.md.

Documentation

The full guide is in docs/en:

• Install and quick start — every dreamteam command
• Features — everything DreamTeam does, in one table
• Terminal UI and console · Session folder and an existing project ·
  Connecting Claude Code · Skills · Agent traces
• Configuration · Docker sandbox and sessions without network ·
  Security
• How it works · Agent tools ·
  Module specification · Terminal UI contract

Ideas are borrowed from Claude Code Agent Teams, Gas Town / Beads, CAMEL Workforce, Magentic-One, MetaGPT,
Strands Swarm, Letta, Alita, A2A and blackboard architectures — details.

Contributing

Issues and pull requests are welcome, in English or Russian. Start with CONTRIBUTING.md;
tests run with a scripted LLM and need no API keys.

License

MIT