ClawTeam: a Python CLI that turns one prompt into a swarm of CLI coding agents

What ClawTeam actually solves, and for whom

A single CLI coding agent works in isolation. You give it a task, it holds the context, and when the task outgrows one context window you are the one splitting it, pasting results between terminals and keeping track of which branch is which. ClawTeam's README states the problem in almost those words: current agents are powerful but work in isolation, and coordinating several of them by hand means juggling context and stitching together fragmented results.

The project's answer is a leader agent that spawns specialized sub-agents, allocates tasks with dependency management, relays messages between them, and reallocates resources and redirects effort. The README describes a demo where a leader agent orchestrates eight sub-agents across eight H100 GPUs, redesigning experiments and moving resources based on live results.

The intended user is someone who already has a CLI agent installed and wants a coordination layer above it rather than a new agent runtime. ClawTeam does not ship a model or an inference stack. It ships a CLI, a task and message layer, and a set of team templates you fill in. If you have never run Claude Code, Codex, OpenClaw or Cursor from a terminal, ClawTeam has nothing to coordinate yet.

How the swarm is wired: leader, sub-agents, transport, templates

The pyproject.toml describes the package as a "Framework-agnostic multi-agent coordination CLI", and that phrase is the architecture in miniature. ClawTeam talks to agents through their command-line interfaces, so the agent binary is a dependency you supply, not one it bundles. The README lists Claude Code, Codex, OpenClaw, nanobot, Cursor and, more generally, any CLI agent.

Above the agents sits the leader, which the README says designs task allocation with dependency management, facilitates inter-agent communication, monitors team performance and identifies bottlenecks, then reallocates resources and redirects effort. Sub-agents get dedicated environments and focus areas.

Messages and tasks move over one of two transports. The README names File and ZeroMQ P2P. File transport is the default picture: agents on the same machine or filesystem read and write shared state. ZeroMQ is an optional extra, declared in pyproject.toml as the p2p group pinning pyzmq between 25.0.0 and 27.0.0. A redis extra exists too, pinning redis between 5.0.0 and 6.0.0.

Team composition is defined in TOML templates. The README points to TOML templates for custom research teams, investment committees, business operations teams and content studios. The repository also carries .agents/, .claude/, skills/ and skills-lock.json at the top level, which suggests agent skills and per-agent configuration are versioned alongside the code rather than generated at runtime.

Installing ClawTeam and running a first team

ClawTeam requires Python 3.10 or newer, per both the README badge and requires-python in pyproject.toml. The package name on PyPI is clawteam, and v0.1.2 is labelled the first PyPI release. The README's comparison table describes setup as `pip install` plus one prompt to the leader.

What the repository files do confirm is the packaging. The clawteam console script is mapped in pyproject.toml to clawteam.cli.commands:app, and a second script, clawteam-mcp, maps to clawteam.mcp.server:main, which is the MCP server entry point. The mcp dependency (mcp>=1.0.0) is a base dependency, not an extra. Two optional groups exist: p2p, which pins pyzmq between 25.0.0 and 27.0.0 for the ZeroMQ transport, and redis, which pins redis between 5.0.0 and 6.0.0. A dev extra brings pytest and ruff.

Once installed, the README shows the commands agents use: `clawteam spawn` to create workers, `clawteam task list` and `clawteam inbox send` to coordinate, and `clawteam board attach` or `clawteam board serve --port 8080` to watch the team. Expect to edit the template before anything useful happens: the leader needs to know which agent binary to launch and what the sub-agents are for.

Where ClawTeam is the wrong tool

The first limitation is stated by the project itself. The classifiers in pyproject.toml declare Development Status 3 - Alpha. The README describes v0.2.0 as a stabilization release, which tells you the interface was still moving as of that release. If you need a coordination layer whose flags and template keys will not shift under you, this is not it yet.

The second is the dependency on an external agent CLI. ClawTeam is framework-agnostic precisely because it does not own the agent. Every failure mode of the underlying CLI agent becomes a failure mode of the swarm.

The third is cost shape. A swarm of eight sub-agents is eight agent sessions running concurrently, each consuming tokens and, in the GPU demo the README describes, compute. Coordination overhead is real: the leader spends turns assigning, monitoring and reallocating. For a task that one agent can finish in a single context window, a swarm adds latency and spend without adding capability.

The fourth is operational. There is a website/ directory and a React and Vite package.json for the project site, but that is the marketing site, not a control plane you can use to recover a stuck run.

How ClawTeam differs from a single-agent CLI and from LangGraph-style frameworks

The closest comparison is the thing you already have. Claude Code, Codex, Cursor and OpenClaw each run one agent with one context. You can approximate a team by opening several terminals and pasting between them, which is exactly the manual coordination the README complains about. ClawTeam's difference is that the split, the message passing and the reallocation are performed by a leader agent rather than by you, and the state lives in files or a ZeroMQ channel instead of your clipboard.

The other comparison is to graph-based orchestration libraries such as LangGraph. Those put the graph in your code: you define nodes, edges and state, and the runtime executes your topology. ClawTeam inverts that. The topology is a TOML template and the leader agent decides the allocation at runtime, which means less code to write and less determinism to rely on. If you need a reproducible pipeline where the same input always produces the same sequence of steps, a coded graph is the better fit. If you want the agent to decide how to divide the work, ClawTeam is aimed at that.

A third difference is surface area. ClawTeam ships an MCP server entry point, so the coordination layer can itself be exposed to MCP-speaking clients. That is a narrower integration story than a full SDK.

Maintenance, versioning and the MIT licence

The repository is not archived. The last push to the default branch was on 2026-05-09. The two releases listed are v0.1.2 (2026-03-18, first PyPI release) and v0.2.0 (2026-03-23, stabilization release), while pyproject.toml on main declares version 0.3.0, so main is ahead of the last tagged release. That gap is worth knowing before you pin a version: installing from PyPI gets you a release, installing from the repository gets you unreleased code.

Upgrade cost is dominated by two things. The dependency ranges are wide and bounded on both ends (typer>=0.12.0,<1.0.0; pydantic>=2.0.0,<3.0.0; rich>=13.0.0,<15.0.0), which keeps major-version breaks out but does not promise API stability for the CLI itself. The TOML team templates are the part most likely to change between releases.

ClawTeam is MIT licensed, stated in the LICENSE file, in the README badge and in pyproject.toml. MIT is permissive: it allows commercial use and modification with attribution and no warranty. That said, the licence covers ClawTeam's own code, not the agents it drives, and not the models behind them. If your swarm calls a hosted agent CLI, that vendor's terms apply to the traffic your sub-agents generate. Nothing here is legal advice; read the licence text and the terms of the agent CLIs you wire in.

Editorial conclusion

Adopt ClawTeam if you already run Claude Code, Codex or another CLI agent and want a leader agent to split work across sub-agents with a file or ZeroMQ transport, and if you are comfortable on an alpha-class package that declares Development Status 3 - Alpha. Do not adopt it if you need a stable interface or a swarm that runs without a human watching the task board. Verify three things first: that your Python is 3.10 or newer, that the CLI agent you plan to drive is actually installed and reachable on PATH, and that the transport you pick (file or the pyzmq extra) matches the way your agents share a machine.

Frequently asked questions

Official sources

1. HKUDS/ClawTeam on GitHub
2. Issues
3. License: MIT
4. README
5. Releases