ClawTeam-OpenClaw

ClawTeam is an agent swarm intelligence platform designed to evolve AI agents from solo entities into collaborative teams. Instead of humans manually orchestrating multiple agents, ClawTeam allows AI agents to form their own teams, decompose complex tasks, share insights in real-time, and dynamically adjust strategies.

Key capabilities include:

• Specialized Sub-agent Creation: Agents get their own dedicated environments and focus areas.
• Intelligent Task Distribution: Tasks are assigned considering dependencies.
• Real-time Collaboration: Agents communicate naturally via CLI-based messaging.
• Team Performance Monitoring: Tracking progress and identifying bottlenecks.
• Dynamic Strategy Adjustment: Reallocating resources and modifying directions autonomously.

ClawTeam is compatible with various CLI agents including Claude Code, Codex, OpenClaw, nanobot, and Cursor.

ClawTeam is a multi-agent orchestration platform that provides:

• Agent Self-Organization: Leaders manage workers with auto-injected coordination prompts and status reporting.
• Workspace Isolation: Each agent operates in its own git worktree (branch naming: clawteam/{team}/{agent}) to prevent merge conflicts.
• Task Tracking: A shared kanban system (pending → in_progress → completed / blocked) with --blocked-by dependency chains that auto-unblock upon task completion.
• Inter-Agent Messaging: Point-to-point inboxes (send, receive, peek) and broadcast capabilities using file-based or ZeroMQ P2P transport.
• Monitoring: Terminal kanban (board show), live dashboards (board live), tiled tmux views (board attach), and a Web UI (board serve).
• Team Templates: TOML-based archetypes that can be launched via clawteam launch <template> with variable substitution for {goal}, {team_name}, and {agent_name}.

ClawTeam provides a multi-agent orchestration layer for OpenClaw agents. Key capabilities include:

• Agent Self-Organization: A leader agent spawns and manages workers. Coordination is handled via automatically injected prompts, requiring zero manual setup. Workers report status and idle states automatically.
• Workspace Isolation: Each agent operates within its own git worktree. This prevents merge conflicts between parallel agents. Branches are named using the pattern clawteam/{team}/{agent}. Commands are available for creating checkpoints, merging, and cleaning up.
• Task Tracking with Dependencies: Uses a Kanban model (pending → in_progress → completed / blocked). Tasks can use the --blocked-by flag to create dependency chains, which automatically unblock dependent tasks upon completion. The task wait command blocks execution until specific tasks are finished.
• Inter-Agent Messaging: Supports bidirectional messaging (send, receive, view) and broadcasting to all team members. Transport defaults to file-based but supports ZeroMQ P2P.
• Monitoring and Dashboards:
  • board show: Terminal-based Kanban board.
  • board live: Auto-refreshing dashboard.
  • board attach: Tiled tmux view of all agents.
  • board serve: Real-time web interface.
• Command Templates: Define agent archetypes (roles, tasks, prompts) using TOML files. Use clawteam launch <template> to start. Templates support variable substitution for {goal}, {team_name}, and {agent_name}.

When both the sender (Agent A) and receiver (Agent B) are online, P2PTransport uses ZeroMQ (ZMQ) for direct TCP communication.

Workflow:

1. Receiver Setup: The receiver (Agent B) starts a listener by calling _start_listener(), which performs a PULL.bind(:port) and writes its connection info to peers/B.json.
2. Sender Action: Agent A calls send("A", "B", data). The MailboxManager delivers this to P2PTransport.
3. Connection: P2PTransport reads peers/B.json to find the address (e.g., tcp://hostB:port), verifies the target PID is alive, and performs a PUSH.connect(addr) followed by PUSH.send(data).
4. Reception: The receiver's PULL.recv() captures the data, and the agent retrieves it via receive("B").

  Agent A (sender)        MailboxManager         P2PTransport               Agent B (receiver)
       │                       │                      │                          │
       │                       │                      │    _start_listener()     │
       │                       │                      │    ┌──────────────────┐  │
       │                       │                      │    │ PULL.bind(:port) │  │
       │                       │                      │    │ 写 peers/B.json  │  │
       │                       │                      │    └──────────────────┘  │
       │                       │                      │                          │
       │  send("A","B","hi")   │                      │                          │
       │──────────────────────►│                      │                          │
       │                       │  deliver("B", data)  │                      │
       │─────────────────────►│                      │                          │
       │                       │                      │                          │
       │                       │                      │  读 peers/B.json         │
       │                       │                      │  → tcp://hostB:port      │
       │                       │                      │  检查 PID 存活? ✓        │
       │                       │                      │  PUSH.connect(addr)      │
       │                       │                      │  PUSH.send(data)         │
       │                       │                      │─────── ZMQ TCP ─────────►│
       │                       │                      │                          │
       │                       │                      │  PULL.recv()              │
       │                       │                      │  收到 data!               │
       │◄─────── ok ───────────│                      │                          │
       │                       │                      │                          │
       │                       │          receive("B") │                      │
       │                       │◄─────────────────────────│                      │
       │                       │  PULL.recv(NOBLOCK)    │                      │
       │                       │  → data                │                      │
       │                       │  (+ 检查文件兜底)       │                      │
       │──── [bytes] ──────────►│                      │                      │
       │                       │                      │                      │

ClawTeam is a coordination layer for CLI-based programming agents (like OpenClaw, Claude Code, or nanobot). Instead of a human writing orchestration code, the agents themselves use the clawteam CLI to self-organize into teams.

Key concepts include:

• Agent-led Orchestration: Agents use the CLI to split tasks, spawn workers, and communicate without manual micro-management.
• Isolation via Git Worktrees: Each worker agent is spawned with its own git worktree, ensuring they work on real branches without interfering with each other's file state.
• Communication via CLI: Agents communicate by sending messages to an 'inbox' or updating task lists using CLI commands, which are automatically injected into their prompts.
• Observability: Users can monitor the swarm's progress using a tmux mosaic view or a web dashboard.

clawteam spawn --team my-team \
  --agent-name worker1 \
  --task "Implement auth module"