ClawTeam: Agent Swarm Intelligence

The Evolution of AI Agents 🚀: Solo 🤖 → Swarm 🦞🤖🤖🤖
ClawTeam: Let AI Agents Form Swarms, Think & Work Together, and Ship Faster

One Command Line: Full Automation. — agents spawn swarms, delegate tasks, and deliver results.

Human provides the goal. The Agent Team orchestrates everything else.

Full compatibility with Claude Code, Codex, OpenClaw, nanobot, Cursor, and any CLI agent.  中文文档 | 한국어

📰 News

2026-03-18 ClawTeam project launched publicly.

2026-03-23 ClawTeam v0.2.0 is released today.

2026-03 The current baseline includes config management, multi-user workflows, Web UI, P2P transport, and team templates.

✨ ClawTeam's Key Features

🔬 AI Research Automation • Large-Scale Automated ML Experimentation • AI Model Training & Optimization • AI-Driven Hypothesis Generation & Validation • Self-Improving Model Architectures

🏗️ Agentic Engineering • Autonomous Full-Stack Development • Self-Evolving Software • Collaborative Open Source Development • Real-Time System Integration

💰 AI Hedge Fund • Automated Market Research & Data Mining • Multi-Strategy Portfolio Optimization • Real-Time Risk Assessment • Algorithmic Trading Execution & Monitoring

🎪 Your Own Swarm • Custom Scientific Research Teams • Personalized Investment Committees • Business Operations Teams • Content Production Studios

☝️ Intelligent leader agent orchestrates 8 specialized sub-agents across 8 H100 GPUs, autonomously designing experiments and dynamically reallocating resources based on real-time performance.

🧠 The system synthesizes breakthroughs across teams and evolves strategies independently — achieving full research automation without human intervention.

🤔 Why ClawTeam?

Current AI agents are powerful — but they work in isolation. When facing complex tasks, you're stuck manually coordinating multiple agents, juggling context, and stitching together fragmented results.

What if agents could think and work as a team?

ClawTeam unlocks Agent Swarm Intelligence — where AI agents self-organize into collaborative teams, intelligently divide complex work, share insights in real-time, and converge on breakthrough solutions.

• 🚀 Spawns specialized sub-agents — each with dedicated environments and focus areas

• 📋 Designs intelligent task allocation — with smart dependency management

• 💬 Facilitates real-time coordination — seamless inter-agent communication

• 📊 Monitors team performance — tracks progress and identifies bottlenecks

• 🔄 Adapts strategies dynamically — reallocates resources and redirects efforts

✨ The Result?

You set the vision. The swarm executes with collective intelligence.

🎯 Swarm Intelligence in Action

# The leader agent runs:
oh spawn --team my-team \
  --agent-name worker1 \
  --task "Implement auth module"

# A worker agent checks tasks:
oh task list my-team --owner me
# Then reports back:
oh inbox send my-team leader \
  "Auth done. All tests passing."

# Watch all agents simultaneously
oh board attach my-team
# Or open the web dashboard
oh board serve --port 8080

🎬 Use Cases

🔬 1. Autonomous ML Research — 8 Agents × 8 H100 GPUs

Based on @karpathy's autoresearch.

💫 One Command. Full Automation.

Human input: "Optimize this LLM training setup using 8 GPUs"

The Agent Team handles everything else:

• Spawns 8 specialized research agents across H100s
• Designs 2000+ autonomous experiments
• Achieves breakthrough improvements (val_bpb: 1.044→0.977)
• Zero human intervention required

🎯 Pure Research at Scale

Transform months of manual hyperparameter tuning into hours of intelligent automation.

🏆 val_bpb: 1.044 → 0.977 (6.4% improvement) | 2430+ experiments | ~30 GPU-hours

What agent team did autonomously:

Human prompt: "Use 8 GPUs to optimize train.py. Read program.md for instructions."

🦞 Leader agent's actions:
├── 📖 Read program.md, understand the experiment protocol
├── 🏗️ oh team spawn-team autoresearch
├── 🚀 Assigned each GPU a research direction:
│   ├── GPU 0: oh spawn --task "Explore model depth (DEPTH 10-16)"
│   ├── GPU 1: oh spawn --task "Explore model width (ASPECT_RATIO 80-128)"
│   ├── GPU 2: oh spawn --task "Tune learning rates and optimizer"
│   ├── GPU 3: oh spawn --task "Explore batch size and accumulation"
│   ├── GPU 4-7: oh spawn tmux codex --task "..."  (Codex agents)
│   └── 🌳 Each agent: own git worktree, own branch, isolated experiments
├── 🔄 Every 30 minutes, checked results:
│   ├── oh board show autoresearch
│   ├── Read each agent's results.tsv
│   ├── 🏆 Identified best findings (depth=12, batch=2^17, norm-before-RoPE)
│   └── 📡 Cross-pollinated: told new agents to start from the best config
├── 🔧 When agents finished, reassigned GPUs:
│   ├── Killed idle agents, cleaned worktrees
│   ├── Created new worktrees from the best commit
│   └── Spawned fresh agents with combined optimization directions
└── ✅ After 2430+ experiments: val_bpb 1.044 → 0.977

Full results: novix-science/autoresearch

🏗️ 2. Agentic Software Engineering

You tell Claude Code: "Build me a full-stack todo app." Claude realizes this is a multi-module task and self-organizes a team:

Human prompt: "Build a full-stack todo app with auth, database, and React frontend."

🦞 Leader agent's actions:
├── 🏗️ oh team spawn-team webapp -d "Full-stack todo app"
├── 📋 Created tasks with dependency chains:
│   ├── T1: "Design REST API schema"          → architect
│   ├── T2: "Implement JWT auth" --blocked-by T1  → backend1
│   ├── T3: "Build database layer" --blocked-by T1 → backend2
│   ├── T4: "Build React frontend"             → frontend
│   └── T5: "Integration tests" --blocked-by T2,T3,T4 → tester
├── 🚀 Spawned 5 sub-agents (each in its own git worktree):
│   ├── oh spawn --agent-name architect --task "Design the API schema"
│   ├── oh spawn --agent-name backend1  --task "Implement JWT auth"
│   ├── oh spawn --agent-name backend2  --task "Build PostgreSQL models"
│   ├── oh spawn --agent-name frontend  --task "Build React UI"
│   └── oh spawn --agent-name tester    --task "Write pytest tests"
├── 🔗 Dependency auto-resolution:
│   ├── architect completes → backend1 and backend2 auto-unblock
│   ├── All backends complete → tester auto-unblocks
│   └── Each agent calls: oh task update <id> --status completed
├── 💬 Sub-agents coordinate via inbox:
│   ├── architect → backend1: "Here's the OpenAPI spec: ..."
│   ├── backend1 → tester: "Auth endpoints ready at /api/auth/*"
│   └── tester → leader: "All 47 tests passing ✅"
└── 🌳 Leader merges all worktrees into main branch

💰 3. AI Hedge Fund — One-Command Team Launch

A pre-built TOML template spawns a complete 7-agent investment analysis team:

# One command launches everything:
oh launch hedge-fund --team fund1 --goal "Analyze AAPL, MSFT, NVDA for Q2 2026"

🦞 What happens automatically:
├── 📊 Portfolio Manager (leader) spawns and receives the goal
├── 🤖 5 Analyst agents spawn, each with a different strategy:
│   ├── 🎩 Buffett Analyst    → value investing (moat, ROE, DCF)
│   ├── 🚀 Growth Analyst     → disruption (TAM, network effects)
│   ├── 📈 Technical Analyst  → indicators (EMA, RSI, Bollinger)
│   ├── 📋 Fundamentals       → financial ratios (P/E, D/E, FCF)
│   └── 📰 Sentiment Analyst  → news + insider trading signals
├── 🛡️ Risk Manager spawns, waits for all analyst signals:
│   ├── oh inbox receive fund1 (collects all 5 signals)
│   ├── Consolidates + computes position limits
│   └── oh inbox send fund1 portfolio-manager "RISK REPORT: ..."
└── 💼 Portfolio Manager makes final buy/sell/hold decisions

Templates are TOML files — create your own team archetypes for any domain.

📦 Install

pip install clawteam

# Or from source
git clone https://github.com/HKUDS/ClawTeam.git
cd ClawTeam
pip install -e .

# Optional: P2P transport (ZeroMQ)
pip install -e ".[p2p]"

Requires Python 3.10+, tmux, and a CLI coding agent (e.g. claude, codex). Python dependencies: typer, pydantic, rich.

All spawn examples assume the agent CLI you name is already installed and available on PATH.

🚀 Quick Start

If you're new to ClawTeam, follow this order:

1. Make sure tmux and your agent CLI run standalone on this machine.
2. Pick one path below: let an agent drive, or drive it manually.
3. Use the supported-agent table to choose the right spawn command.
4. If you're integrating a new agent, check the adapter notes before debugging.

✅ Before You Start

Run these checks first:

tmux -V
oh --help

# Replace claude with the agent you actually want to use:
claude --version
codex --version
nanobot --help

If the agent CLI does not run correctly by itself, oh spawn will not fix it.

⚡ Option 1: Let the Agent Drive (Recommended)

ClawTeam ships with a reusable skill in skills/clawteam/.

Claude Code

Install the skill into ~/.claude/skills/clawteam, then prompt:

"Build a web app. Use oh to split the work across multiple agents."

Codex

Install the same skill into $CODEX_HOME/skills/clawteam (typically ~/.codex/skills/clawteam), then prompt:

Use $oh to split this task across multiple agents and coordinate the team to completion.

The agent will automatically create a team, spawn workers, assign tasks, and coordinate — using oh CLI commands under the hood.

🔧 Option 2: Drive It Manually

# 1. Create a team (you become the leader)
oh team spawn-team my-team -d "Build the auth module" -n leader

# 2. Spawn worker agents — each gets a git worktree, tmux window, and identity
oh spawn --team my-team --agent-name alice --task "Implement the OAuth2 flow"
oh spawn --team my-team --agent-name bob   --task "Write unit tests for auth"

# 3. Workers auto-receive a coordination prompt that teaches them to:
#    ✅ Check tasks:    oh task list my-team --owner alice
#    ✅ Update status:  oh task update my-team <id> --status completed
#    ✅ Message leader: oh inbox send my-team leader "Done!"
#    ✅ Report idle:    oh lifecycle idle my-team

# 4. Watch them work side-by-side
oh board attach my-team

🧩 Profiles and Presets

When you want to use a non-default provider, model, or API gateway, configure a profile first instead of manually exporting provider env vars each time.

# See built-in provider templates
oh preset list
oh preset show moonshot-cn

# Generate a reusable runtime profile from a preset
oh preset generate-profile moonshot-cn claude --name claude-kimi

# MiniMax (M2.7) — global or China endpoint
oh preset generate-profile minimax-global claude --name claude-minimax
oh preset generate-profile minimax-cn claude --name claude-minimax-cn

# Or use the interactive TUI
oh profile wizard

# Claude Code on a fresh machine/home may need this once
oh profile doctor claude

# Smoke-test the profile before spawning workers
MOONSHOT_API_KEY=... oh profile test claude-kimi
MINIMAX_API_KEY=... oh profile test claude-minimax

Rules of thumb:

• profile is the final runtime object used by spawn / launch
• preset is a reusable provider template that generates one or more profiles
• wizard is the easiest path for first-time setup
• doctor is mainly for Claude Code first-run onboarding state

🧭 Which Spawn Command Should I Use?

Use oh spawn [backend] [command] ... with the command that already works on your machine:

# Claude Code
oh spawn tmux claude --team my-team --agent-name alice --task "Implement OAuth2"

# Codex
oh spawn tmux codex --team my-team --agent-name bob --task "Write frontend tests"

# nanobot
oh spawn tmux nanobot --team my-team --agent-name carol --task "Build the API"

# A configured profile (recommended for non-default providers/models)
oh spawn tmux --profile claude-kimi --team my-team --agent-name dave --task "Refactor the auth flow"

Notes:

• tmux is the default backend and is the best choice when you want to watch interactive agent UIs.
• subprocess is better for one-shot tools or non-interactive scripts.
• nanobot is normalized internally to nanobot agent, so the command above is the correct ClawTeam entrypoint.
• Claude Code and Codex trust prompts in fresh worktrees are auto-confirmed by the tmux backend.
• For non-default providers/models, prefer --profile <name> over manually exporting env vars inline.

🔌 Adding a Different Agent

ClawTeam can work with agents beyond Claude Code, Codex, and nanobot, but the CLI must satisfy a small compatibility contract:

1. The command must exist on PATH and launch successfully outside ClawTeam.
2. The agent must be able to run inside a specific working directory or git worktree.
3. The agent must accept an initial task, either by command-line argument or interactive input.
4. The process must stay alive in tmux if it is meant to be interactive.

If you're unsure, test the agent standalone first, then wrap it with:

oh spawn subprocess <your-agent> --team my-team --agent-name test --task "Say OK"

If that works, switch to tmux for interactive monitoring.

🤖 Supported Agents

ClawTeam works with any CLI agent that can execute shell commands:

All examples below assume the corresponding CLI already runs standalone on your machine.

For provider-aware setups such as Claude Code via Moonshot Kimi, MiniMax, or Gemini via Vertex, use profile + preset and then spawn with --profile.

✨ Features

🔧 More

🤖 How Agents Use ClawTeam

When an agent is spawned via oh spawn, it receives an auto-injected coordination prompt:

## Coordination Protocol (auto-injected into every spawned agent)

- 📋 Check your tasks: oh task list <team> --owner <your-name>
- ▶️ Start a task:     oh task update <team> <id> --status in_progress
- ✅ Finish a task:    oh task update <team> <id> --status completed
- 💬 Message leader:   oh inbox send <team> leader "status update..."
- 💬 Message teammate: oh inbox send <team> <name> "info..."
- 📨 Check inbox:      oh inbox receive <team>
- 😴 Report idle:      oh lifecycle idle <team>

This means any CLI agent can participate in a ClawTeam team — it just needs to run shell commands. No custom SDK, no API integration, no framework lock-in.

📖 Command Reference

# 🏗️ Team lifecycle
oh team spawn-team <team> -d "description" -n <leader>
oh team discover                    # List all teams
oh team status <team>               # Show members
oh team cleanup <team> --force      # Delete team

# 🚀 Spawn agents
oh spawn --team <team> --agent-name <name> --task "do this"
oh spawn tmux codex --team <team> --agent-name <name> --task "do this"

# 📋 Task management
oh task create <team> "subject" -o <owner> --blocked-by <id1>,<id2>
oh task update <team> <id> --status completed   # auto-unblocks dependents
oh task list <team> --status blocked --owner worker1
oh task wait <team> --timeout 300

# 💬 Messaging
oh inbox send <team> <to> "message"
oh inbox broadcast <team> "message"
oh inbox receive <team>             # consume messages
oh inbox peek <team>                # read without consuming

# 📊 Monitoring
oh board show <team>                # terminal kanban
oh board live <team> --interval 3   # auto-refresh
oh board attach <team>              # tiled tmux view
oh board serve --port 8080          # web UI

# 🌳 Workspace (git worktree management)
oh workspace list <team>
oh workspace checkpoint <team> <agent>    # auto-commit
oh workspace merge <team> <agent>         # merge back to main
oh workspace cleanup <team> <agent>       # remove worktree

# 📝 Plan approval
oh plan submit <team> <agent> "plan" --summary "TL;DR"
oh plan approve <team> <plan-id> <agent> --feedback "LGTM"
oh plan reject <team> <plan-id> <agent> --feedback "Revise X"

# 🔄 Lifecycle
oh lifecycle request-shutdown <team> <agent> --reason "done"
oh lifecycle approve-shutdown <team> <request-id> <agent>
oh lifecycle idle <team>

# 🎪 Templates
oh launch <template> --team <name> --goal "Build X"
oh template list

# ⚙️ Config
oh config show
oh config set transport p2p
oh config health

🏗️ Architecture

  Human: "Optimize this LLM"
         │
         ▼
  ┌──────────────┐     oh spawn     ┌──────────────┐
  │ 🦞 Leader    │ ──────────────────────► │ 🤖 Worker    │
  │ (Claude Code)│ ──────┐                │ (Claude Code)│
  │              │       │                │ git worktree │
  │ Uses:        │       │                │ tmux window  │
  │ • spawn      │       │ oh spawn └──────────────┘
  │ • task create│       │
  │ • inbox send │       ▼                ┌──────────────┐
  │ • board show │ ──────────────────────► │ 🤖 Worker    │
  │ • task wait  │       │                │ (Codex)      │
  └──────────────┘       │                │ git worktree │
                         │                │ tmux window  │
                         │ oh spawn └──────────────┘
                         ▼
                   ┌──────────────┐
                   │ 🤖 Worker    │    Each worker uses:
                   │ (any CLI)    │    • task list (check work)
                   │ git worktree │    • task update (report done)
                   │ tmux window  │    • inbox send (message leader)
                   └──────────────┘    • inbox receive (get instructions)
                         │
                         ▼
              ┌─────────────────────┐
              │    ~/.clawteam/     │
              │ ├── teams/   (who) │
              │ ├── tasks/   (what)│
              │ ├── inboxes/ (talk)│
              │ └── workspaces/    │
              │     (isolated code)│
              └─────────────────────┘

All state lives in ~/.clawteam/ as JSON files. No database, no server, no cloud. Atomic tmp + rename writes ensure crash safety.

🗺️ Roadmap

Milestones

For the longer-term plan, see ROADMAP.md.

🤝 Contributing

We welcome contributions! ClawTeam is designed to be extensible:

• 🤖 New agent integrations — Add support for more AI coding agents
• 🎪 Team templates — Create TOML templates for new domains (DevOps, data science, etc.)
• 🔌 Transport backends — Redis, NATS, or other message transports
• 📊 Dashboard improvements — Enhanced Web UI, Grafana integration
• 📖 Documentation — Tutorials, best practices, agent prompt engineering guides

📖 Acknowledgements

• @karpathy/autoresearch — the autonomous ML research framework used in our 8-agent swarm demo
• Claude Code and Codex — AI coding agents that work as ClawTeam team members
• ai-hedge-fund — inspiration for the multi-analyst hedge fund template
• CLI-Anything — sister project making all software agent-native

⭐ Star History

If you find ClawTeam helpful, please consider giving us a star! ⭐

📄 License

MIT License — free to use, modify, and distribute.

ClawTeam — Agent Swarm Intelligence. 🦞

_{8 agents × 8 H100s × 2430 experiments × one CLI × one swarm}

Thanks for visiting ✨ ClawTeam!