TeamClaw turns one or more OpenClaw instances into a virtual software company. A controller takes the intake, routes execution-ready work to role-based workers, blocks on real questions instead of guessing, and syncs everything through git.
npx -y @teamclaws/teamclaw install
OpenClaw 2026.3.24+ · Node 22+ · process, Docker or Kubernetes workers
No forty-ticket speculative backlog. The controller creates work that can start now, then keeps the flow moving stage by stage until the outcome lands.
You describe the outcome. The controller asks the sharp questions and writes execution-ready tasks — not a wishlist.
Missing decision, credential or infra? The task blocks and asks you. It never improvises.
Work lands with the right specialist, carrying a role prompt that knows exactly what its job is.
Results publish through git. The controller opens the next stage, and the loop keeps moving.
Every assignment, block and resume is visible — in the controller UI, over WebSocket, and in the message log. No opaque prompt chaining.
Each role runs with its own prompt, its own tools and its own lane. Handoffs go through the controller, artifacts go through git.
Owns scope and priorities. Turns fuzzy asks into decidable work.
Owns structure, trade-offs and interfaces before code gets written.
Writes the code, ships the branch, answers for the diff.
Breaks it before your users do. Blocks on real gaps.
Cuts versions, writes the changelog, pushes the tag.
Provisions the ground it all runs on — never assumes it exists.
Pipelines, deploys and the pager nobody wants to hold.
Threat-models the design and hardens the edges.
Product and UI design with a point of view.
Positioning, launch notes and the story around the ship.
Pipelines, schemas and the plumbing between them.
Roles are built in. The controller routes by role — you never play matchmaker.
Start with process workers on a single machine. Grow to containers or Kubernetes pods when the work demands it — same controller, same flow, same UI.
Long-lived nodes on other machines register back to the controller over HTTP. Multi-machine role separation from day one.
{ "mode": "worker", "role": "developer",
"controllerUrl": "http://ctrl:9527" }
Same-host workers spawned on demand and torn down when idle. The recommended first setup — no networking homework.
{ "mode": "controller",
"workerProvisioningType": "process",
"workerProvisioningMaxPerRole": 10 }
Isolated container workers from the published runtime image, with named volumes for persistent workspaces.
{ "workerProvisioningType": "docker",
"workerProvisioningImage":
"ghcr.io/topcheer/teamclaw-openclaw" }
Worker pods through kubectl, cluster-native. Same registration, same routing — just schedulers instead of shells.
{ "workerProvisioningType": "kubernetes" }
When a role can't safely continue — a missing product decision, a credential, a dependency that doesn't exist yet — TeamClaw raises a clarification and parks the task. You answer, it resumes. Infra work never pretends the infrastructure is already there.
Webhook tests need a Stripe key. Which environment — test, or the sandbox mirror?
The controller initializes the repository. Workers sync before they execute and publish after they finish. Nothing important lives only in a chat transcript.
Workers pull the workspace repo before task execution starts.
Role work happens on its lane, with diffs you can actually review.
Push to the configured remote — or bundle through the controller.
No external Git service? No problem. The controller hosts bundle endpoints so distributed workers keep syncing. Configure a gitRemoteUrl and workers switch to plain clone / pull / push the moment it's reachable.
One command. A controller, eleven specialists, and a flow that keeps moving until it ships.
npx -y @teamclaws/teamclaw install