ClawTeam 深度解析

## 项目简介 **ClawTeam** 是一个 **框架无关的多智能体协调 CLI 工具**，它让 AI 智能体能够自主组织成团队——分配任务、相互通信、协调工作并合并结果，而无需人工微观管理。 这是 [HKUDS/ClawTeam](https://github.com/HKUDS/ClawTeam) 的一个分支版本，深度集成了 [OpenClaw](https://openclaw.ai) 作为默认代理后端。核心创新点包括： - **默认 OpenClaw 代理**：开箱即用的智能体支持 - **每代理会话隔离**：每个代理拥有独立的 git worktree 和 tmux 窗口 - **执行批准自动配置**：自动处理 OpenClaw 的权限审批 - **生产级 spawn 后端**：经过实战验证的代理启动机制 --- ## 整体架构 ClawTeam 采用**去中心化的文件系统架构**，所有状态存储在 `~/.clawteam/` 目录中，无需数据库或中央服务器。 ``` ┌─────────────────────────────────────────────────────────────────┐ │ 用户 / Leader 代理 │ │ (通过 clawteam CLI 驱动) │ └────────────────────────────┬────────────────────────────────────┘ │ ┌───────────────────┼───────────────────┐ │ │ │ ▼ ▼ ▼ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Spawn 系统 │ │ Team 管理 │ │ Workspace │ │ (启动代理) │ │ (团队配置) │ │ (git worktree)│ └────────┬────────┘ └────────┬────────┘ └────────┬────────┘ │ │ │ └───────────────────┼───────────────────┘ │ ▼ ┌──────────────────────────────┐ │ Transport 抽象层 │ │ (FileTransport / P2P) │ └──────────────┬───────────────┘ │ ┌───────────────────┼───────────────────┐ │ │ │ ▼ ▼ ▼ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Task Store │ │ Mailbox │ │ Board │ │ (任务依赖) │ │ (消息队列) │ │ (监控看板) │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ ▼ ┌──────────────────────────────┐ │ ~/.clawteam/ 文件系统 │ │ ├── teams/ (团队配置) │ │ ├── tasks/ (任务状态) │ │ ├── inboxes/ (消息队列) │ │ ├── workspaces/(git worktree)│ │ └── events/ (事件日志) │ └──────────────────────────────┘ ``` --- ## 核心模块详解 ### 1. CLI 命令系统 (`clawteam/cli/commands.py`) **文件路径**: `clawteam/cli/commands.py` 这是整个项目的入口点，使用 **Typer** 框架构建命令行界面。核心命令组包括： ```python # 命令组织结构 clawteam ├── config # 配置管理 (show/set/get/health) ├── team # 团队生命周期 (spawn-team/discover/cleanup/status) ├── inbox # 消息系统 (send/broadcast/receive/peek/log/watch) ├── task # 任务管理 (create/update/list/stats) ├── cost # 成本追踪 (report/show/budget) ├── spawn # 代理启动 (tmux/subprocess 后端) ├── workspace # 工作区管理 (list/checkpoint/merge/cleanup) ├── board # 监控看板 (show/live/attach/serve) ├── session # 会话管理 (save/restore) ├── lifecycle # 生命周期 (request-shutdown/idle/on-exit) ├── plan # 计划审批 (submit/approve/reject) └── launch # 模板启动 (hedge-fund/code-review 等) ``` **关键设计特点**： - 全局选项支持：`--json` 输出、`--data-dir` 覆盖、`--transport` 选择 - 统一的输出处理：`_output()` 函数自动处理 JSON/人类可读格式 - 命令分组：使用 `typer.Typer()` 创建子命令组，通过 `app.add_typer()` 注册 ### 2. 配置系统 (`clawteam/config.py`) **文件路径**: `clawteam/config.py` 采用 **三层优先级配置**：环境变量 > 配置文件 > 默认值 ```python class ClawTeamConfig(BaseModel): data_dir: str = "" # 数据目录 (默认 ~/.clawteam) user: str = "" # 用户标识 (多用户协作) default_team: str = "" # 默认团队名 transport: str = "" # 传输后端 (file/p2p) workspace: str = "auto" # 工作区模式 (auto/always/never) default_backend: str = "tmux" # spawn 后端 (tmux/subprocess) skip_permissions: bool = True # 跳过权限检查 (Claude Code) ``` **配置优先级实现**： ```python def get_effective(key: str) -> tuple[str, str]: """返回 (值，来源)""" # 1. 检查环境变量 env_val = os.environ.get(env_map[key]) if env_val: return env_val, "env" # 2. 检查配置文件 file_val = getattr(cfg, key, "") if file_val != default_val: return str(file_val), "file" # 3. 返回默认值 return str(default_val), "default" ``` ### 3. 代理身份系统 (`clawteam/identity.py`) **文件路径**: `clawteam/identity.py` 支持多前缀环境变量，兼容 CLAWTEAM_*、OPENCLAW_*、CLAUDE_CODE_*： ```python @dataclass class AgentIdentity: agent_id: str = field(default_factory=lambda: uuid.uuid4().hex[:12]) agent_name: str = "agent" user: str = "" agent_type: str = "general-purpose" team_name: str | None = None is_leader: bool = False plan_mode_required: bool = False @classmethod def from_env(cls) -> AgentIdentity: """从环境变量构建身份""" return cls( agent_id=_env("CLAWTEAM_AGENT_ID", "CLAUDE_CODE_AGENT_ID", ...), agent_name=_env("CLAWTEAM_AGENT_NAME", "CLAUDE_CODE_AGENT_NAME", ...), team_name=_env("CLAWTEAM_TEAM_NAME", "CLAUDE_CODE_TEAM_NAME") or None, is_leader=_env_bool("CLAWTEAM_AGENT_LEADER", "CLAUDE_CODE_AGENT_LEADER"), ) ``` ### 4. 团队管理系统 (`clawteam/team/`) #### 4.1 团队管理器 (`manager.py`) **文件路径**: `clawteam/team/manager.py` 负责团队的生命周期操作： ```python class TeamManager: @staticmethod def create_team(name, leader_name, leader_id, description, user): """创建团队并注册 leader""" @staticmethod def discover_teams() -> list[dict]: """发现所有团队""" @staticmethod def add_member(team_name, member_name, agent_id, agent_type, user): """添加成员（创建 inbox）""" @staticmethod def cleanup(team_name) -> bool: """删除团队及所有数据""" ``` **团队配置结构** (`~/.clawteam/teams/{team}/config.json`)： ```json { "name": "my-team", "description": "Build a web app", "leadAgentId": "abc123", "createdAt": "2026-03-20T10:00:00Z", "members": [ {"name": "leader", "user": "alice", "agentId": "abc123", "agentType": "leader"}, {"name": "worker1", "user": "alice", "agentId": "def456", "agentType": "general-purpose"} ], "budgetCents": 1000 } ``` #### 4.2 任务系统 (`tasks.py`) **文件路径**: `clawteam/team/tasks.py` 实现 **基于文件锁的任务存储**，支持任务依赖链： ```python class TaskStore: def create(self, subject, description, owner, blocks, blocked_by, metadata): """创建任务，支持依赖关系""" def update(self, task_id, status, owner, caller, force): """更新任务状态，自动解锁依赖""" def _resolve_dependents_unlocked(self, completed_task_id): """当任务完成时，自动解除依赖该任务的其他任务""" ``` **任务状态机**： ``` pending ──► in_progress ──► completed ▲ │ │ ▼ blocked ◄───────┘ ``` **文件锁机制**： ```python @contextmanager def _write_lock(self): lock_path = _tasks_lock_path(self.team_name) with lock_path.open("a+", encoding="utf-8") as lock_file: fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX) # 独占锁 try: yield finally: fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN) # 释放锁 ``` #### 4.3 邮箱系统 (`mailbox.py`) **文件路径**: `clawteam/team/mailbox.py` 实现**可插拔的传输层抽象**： ```python class MailboxManager: def __init__(self, team_name, transport=None): self._transport = transport or _default_transport(team_name) def send(self, from_agent, to, content, msg_type, ...): """发送点对点消息""" def broadcast(self, from_agent, content, exclude): """广播消息给所有成员""" def receive(self, agent_name, limit) -> list[TeamMessage]: """接收并消费消息（FIFO）""" def peek(self, agent_name) -> list[TeamMessage]: """查看消息但不消费""" ``` **传输层接口** (`transport/base.py`)： ```python class Transport(ABC): @abstractmethod def deliver(self, recipient: str, data: bytes) -> None: """投递消息到收件箱""" @abstractmethod def fetch(self, agent_name: str, limit: int, consume: bool) -> list[bytes]: """获取消息""" @abstractmethod def count(self, agent_name: str) -> int: """返回待处理消息数""" ``` ### 5. Spawn 系统 (`clawteam/spawn/`) #### 5.1 Tmux 后端 (`tmux_backend.py`) **文件路径**: `clawteam/spawn/tmux_backend.py` 这是核心功能——在 tmux 中启动代理，实现可视化监控： ```python class TmuxBackend(SpawnBackend): def spawn(self, command, agent_name, agent_id, agent_type, team_name, prompt, env, cwd): # 1. 构建环境变量 env_vars = { "CLAWTEAM_AGENT_ID": agent_id, "CLAWTEAM_AGENT_NAME": agent_name, "CLAWTEAM_TEAM_NAME": team_name, "CLAWTEAM_AGENT_LEADER": "0", } # 2. 构建命令（添加 --dangerously-skip-permissions 等） final_command = self._build_command(command, skip_permissions, prompt) # 3. 创建 tmux session/window session_name = f"clawteam-{team_name}" target = f"{session_name}:{agent_name}" # 4. 发送 prompt 到交互式会话 self._send_prompt(target, prompt) # 5. 注册 spawn 信息（用于存活检查） register_agent(team_name, agent_name, "tmux", tmux_target=target, pid=pane_pid) ``` **关键特性**： - **自动处理 workspace trust 提示**：检测 Claude Code/Codex 的目录信任提示并自动确认 - **Prompt 注入**：使用 `load-buffer` + `paste-buffer` 避免多行 prompt 的转义问题 - **退出钩子**：代理退出时自动触发 `clawteam lifecycle on-exit` - **存活检查**：通过 tmux pane 状态和 PID 双重检查代理是否存活 #### 5.2 Spawn 注册表 (`registry.py`) **文件路径**: `clawteam/spawn/registry.py` 持久化代理进程信息，用于存活检查： ```python def register_agent(team_name, agent_name, backend, tmux_target, pid, command): """原子写入 spawn 信息""" def is_agent_alive(team_name, agent_name) -> bool | None: """检查代理是否存活""" # tmux 后端：检查 pane_dead 标志 # subprocess 后端：检查 PID def list_dead_agents(team_name) -> list[str]: """返回已死亡的代理名称""" ``` #### 5.3 Prompt 构建器 (`prompt.py`) **文件路径**: `clawteam/spawn/prompt.py` 为 spawned 代理构建初始 prompt： ```python def build_agent_prompt(agent_name, agent_id, agent_type, team_name, leader_name, task, workspace_dir, workspace_branch): """构建包含身份、任务、协调协议的 prompt""" return f""" ## Identity - Name: {agent_name} - ID: {agent_id} - Team: {team_name} - Leader: {leader_name} ## Workspace - Working directory: {workspace_dir} - Branch: {workspace_branch} ## Task {task} ## Coordination Protocol - Use `clawteam task list {team_name} --owner {agent_name}` to see your tasks - Starting: `clawteam task update {team_name} <task-id> --status in_progress` - Finishing: `clawteam task update {team_name} <task-id> --status completed` - Report: `clawteam inbox send {team_name} {leader_name} "All tasks completed..."` """ ``` ### 6. Workspace 系统 (`clawteam/workspace/`) #### 6.1 工作区管理器 (`manager.py`) **文件路径**: `clawteam/workspace/manager.py` 基于 **git worktree** 实现代理工作隔离： ```python class WorkspaceManager: def create_workspace(self, team_name, agent_name, agent_id): """创建 git worktree 和分支""" branch = f"clawteam/{team_name}/{agent_name}" wt_path = _workspaces_root() / team_name / agent_name git.create_worktree(self.repo_root, wt_path, branch, base_ref=self.base_branch) def checkpoint(self, team_name, agent_name, message): """提交当前工作作为检查点""" def merge_workspace(self, team_name, agent_name, target_branch, cleanup_after): """合并工作区到目标分支""" def cleanup_workspace(self, team_name, agent_name, auto_checkpoint): """清理工作区（可选自动 checkpoint）""" ``` **工作区注册表** (`~/.clawteam/workspaces/{team}/workspace-registry.json`)： ```json { "team_name": "my-team", "repo_root": "/path/to/repo", "workspaces": [ { "agent_name": "worker1", "agent_id": "abc123", "branch_name": "clawteam/my-team/worker1", "worktree_path": "~/.clawteam/workspaces/my-team/worker1", "created_at": "2026-03-20T10:00:00Z" } ] } ``` #### 6.2 Git 操作封装 (`git.py`) 封装 git 命令，提供工作区操作： ```python def repo_root(cwd: Path) -> Path: """找到 git 仓库根目录""" def create_worktree(repo_root, wt_path, branch, base_ref): """创建 worktree 和分支""" def remove_worktree(repo_root, wt_path): """删除 worktree""" def merge_branch(repo_root, source_branch, target_branch): """合并分支""" ``` ### 7. Board 监控系统 (`clawteam/board/`) #### 7.1 Web 服务器 (`server.py`) **文件路径**: `clawteam/board/server.py` 使用 Python 标准库实现轻量级 HTTP 服务器： ```python def serve(host, port, default_team, interval): """启动 Web UI 服务器""" server = ThreadingHTTPServer((host, port), BoardHandler) server.serve_forever() class BoardHandler(BaseHTTPRequestHandler): def do_GET(self): if self.path == "/": self._serve_static("index.html") elif self.path == "/api/overview": self._serve_json(self.collector.collect_overview()) elif self.path.startswith("/api/team/"): self._serve_team(team_name) elif self.path.startswith("/api/events/"): self._serve_sse(team_name) # Server-Sent Events ``` **SSE 实时推送**： ```python def _serve_sse(self, team_name): self.send_response(200) self.send_header("Content-Type", "text/event-stream") while True: data = self.collector.collect_team(team_name) self.wfile.write(f"data: {json.dumps(data)}\n\n".encode()) time.sleep(self.interval) ``` #### 7.2 数据收集器 (`collector.py`) 收集团队状态数据供 Web UI 使用： ```python class BoardCollector: def collect_overview(self) -> dict: """收集所有团队概览""" def collect_team(self, team_name) -> dict: """收集单个团队的详细状态""" return { "config": team_config, "tasks": task_list, "members": member_status, "costs": cost_summary, } ``` ### 8. 模板系统 (`clawteam/templates/`) **文件路径**: `clawteam/templates/` 使用 TOML 文件定义团队模板，一键启动复杂的多代理团队： **示例：对冲基金模板** (`hedge-fund.toml`)： ```toml [template] name = "hedge-fund" description = "AI Hedge Fund - multi-agent investment analysis team" command = ["openclaw"] backend = "tmux" [template.leader] name = "portfolio-manager" type = "portfolio-manager" task = """你是投资组合经理...""" [[template.agents]] name = "buffett-analyst" type = "value-analyst" task = """你是沃伦·巴菲特，使用价值投资原则分析股票...""" [[template.agents]] name = "growth-analyst" type = "growth-analyst" task = """你是成长型投资者...""" [[template.tasks]] subject = "协调分析并做出最终投资决策" owner = "portfolio-manager" [[template.tasks]] subject = "价值投资分析（巴菲特风格）" owner = "buffett-analyst" ``` **内置模板**： - `hedge-fund.toml` - AI 对冲基金（7 个代理） - `code-review.toml` - 代码审查团队 - `research-paper.toml` - 研究论文团队 - `strategy-room.toml` - 战略会议室 --- ## 设计思想与模式 ### 1. 文件系统即数据库 **核心理念**：所有状态存储在 `~/.clawteam/` 目录中，无需数据库或中央服务器。 ``` ~/.clawteam/ ├── config.json # 全局配置 ├── teams/ │ └── {team}/ │ ├── config.json # 团队配置 │ ├── inboxes/ # 消息队列 │ │ ├── {agent}/ │ │ │ └── msg-*.json │ │ └── _pending_*/ # 临时收件箱（加入请求） │ └── events/ # 事件日志 ├── tasks/ │ └── {team}/ │ ├── task-*.json # 任务文件 │ └── .tasks.lock # 文件锁 ├── workspaces/ │ └── {team}/ │ ├── {agent}/ # git worktree │ └── workspace-registry.json ├── costs/ │ └── {team}/ │ └── cost-*.json ├── sessions/ │ └── {team}/ │ └── session-*.json └── plans/ └── {team}/ └── plan-*.json ``` **优势**： - 零依赖：不需要数据库、Redis 等外部服务 - 可移植：整个状态就是一个目录，可轻松备份/迁移 - 可观察：直接用文本编辑器即可查看状态 - 原子性：使用 `write tmp + rename` 模式确保原子写入 ### 2. 传输层抽象 **设计模式**：策略模式（Strategy Pattern） ```python # 抽象接口 class Transport(ABC): @abstractmethod def deliver(self, recipient, data): ... @abstractmethod def fetch(self, agent_name, limit, consume): ... # 具体实现 class FileTransport(Transport): """基于文件系统的传输（默认）""" class P2PTransport(Transport): """基于 ZeroMQ 的 P2P 传输""" ``` **优势**： - 可插拔：通过 `CLAWTEAM_TRANSPORT=file|p2p` 切换后端 - 可扩展：轻松添加 Redis、NATS 等新传输 - 向后兼容：现有代码无需修改 ### 3. 多用户协作设计 **命名空间隔离**：使用 `(user, agent_name)` 复合键区分不同用户的代理。 ```python # 收件箱命名 inbox_name = f"{user}_{agent_name}" if user else agent_name # 成员唯一性检查 for m in config.members: if m.name == member_name and m.user == user: raise ValueError("Agent already in team") ``` **用户标识来源**： 1. `CLAWTEAM_USER` 环境变量 2. `clawteam config set user <name>` 配置 3. 默认为空（单用户模式） ### 4. 任务依赖链 **设计模式**：观察者模式（Observer Pattern）的变体 ```python # 任务创建时指定依赖 task = store.create( subject="Build frontend", blocked_by=["task-123", "task-456"] # 被这些任务阻塞 ) # 任务完成时自动解锁依赖 def _resolve_dependents_unlocked(self, completed_task_id): for task in all_tasks: if completed_task_id in task.blocked_by: task.blocked_by.remove(completed_task_id) if not task.blocked_by and task.status == TaskStatus.blocked: task.status = TaskStatus.pending # 自动解锁 ``` ### 5. 文件锁机制 **设计模式**：互斥锁（Mutex） ```python @contextmanager def _write_lock(self): lock_path = _tasks_lock_path(self.team_name) with lock_path.open("a+", encoding="utf-8") as lock_file: fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX) # 独占锁 try: yield finally: fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN) ``` **任务级锁**： ```python def _acquire_lock(self, task, caller, force): if task.locked_by and task.locked_by != caller and not force: # 检查锁持有者是否存活 alive = is_agent_alive(self.team_name, task.locked_by) if alive is not False: raise TaskLockError("Task is locked by another agent") task.locked_by = caller ``` ### 6. 模板驱动的团队创建 **设计模式**：模板方法模式（Template Method Pattern） ```python # TOML 模板定义团队结构 [template] name = "hedge-fund" command = ["openclaw"] [template.leader] name = "portfolio-manager" task = "..." [[template.agents]] name = "analyst-1" task = "..." [[template.tasks]] subject = "..." owner = "analyst-1" ``` **变量替换**： - `{goal}` - 团队目标 - `{team_name}` - 团队名称 - `{agent_name}` - 代理名称 --- ## 技术亮点 ### 1. 原子写入模式 所有 JSON 文件写入都使用 **write-tmp-then-rename** 模式： ```python def _save_config(config: TeamConfig) -> None: path = _config_path(config.name) tmp = path.with_suffix(".tmp") tmp.write_text(config.model_dump_json(indent=2), encoding="utf-8") tmp.rename(path) # 原子操作 ``` **优势**：即使进程崩溃，也不会留下损坏的文件。 ### 2. 进程存活检查 双重检查机制确保准确判断代理状态： ```python def is_agent_alive(team_name, agent_name): info = registry.get(agent_name) if backend == "tmux": # 1. 检查 tmux pane_dead 标志 alive = _tmux_pane_alive(info.get("tmux_target")) if alive is False: # 2. 回退到 PID 检查 return _pid_alive(info.get("pid")) return alive elif backend == "subprocess": return _pid_alive(info.get("pid")) ``` ### 3. 智能 Prompt 注入 针对多行 prompt 的转义问题，使用 tmux buffer 机制： ```python # 写入临时文件 with tempfile.NamedTemporaryFile(mode="w", suffix=".txt") as f: f.write(prompt) tmp_path = f.name # 使用 load-buffer + paste-buffer subprocess.run(["tmux", "load-buffer", "-b", f"prompt-{agent_name}", tmp_path]) subprocess.run(["tmux", "paste-buffer", "-b", f"prompt-{agent_name}", "-t", target]) ``` ### 4. 自动 Workspace Trust 确认 检测并自动确认 Claude Code/Codex 的目录信任提示： ```python def _confirm_workspace_trust_if_prompted(target, command): deadline = time.monotonic() + timeout_seconds while time.monotonic() < deadline: pane_text = _capture_tmux_pane(target) if _looks_like_workspace_trust_prompt(command, pane_text): subprocess.run(["tmux", "send-keys", "-t", target, "Enter"]) return True time.sleep(poll_interval) ``` ### 5. SSE 实时推送 Web UI 使用 Server-Sent Events 实现实时更新： ```python def _serve_sse(self, team_name): self.send_response(200) self.send_header("Content-Type", "text/event-stream") while True: data = self.collector.collect_team(team_name) self.wfile.write(f"data: {json.dumps(data)}\n\n".encode()) time.sleep(self.interval) # 可配置的更新间隔 ``` --- ## 使用流程 ### 典型工作流 ```bash # 1. 创建团队 clawteam team spawn-team my-team -d "Build a web app" -n leader # 2. 启动 Worker 代理 clawteam spawn --team my-team --agent-name alice --task "Implement auth" clawteam spawn --team my-team --agent-name bob --task "Write tests" # 3. 监控进度 clawteam board show my-team # 终端看板 clawteam board live my-team # 自动刷新 clawteam board attach my-team # tmux 平铺视图 clawteam board serve --port 8080 # Web UI # 4. 任务管理 clawteam task list my-team --owner alice clawteam task update my-team <id> --status completed # 5. 消息通信 clawteam inbox send my-team alice "Need help with..." clawteam inbox broadcast my-team "Meeting in 5 minutes" # 6. 工作区管理 clawteam workspace list my-team clawteam workspace checkpoint my-team alice clawteam workspace merge my-team alice # 7. 清理 clawteam team cleanup my-team ``` ### 模板启动 ```bash # 一键启动对冲基金团队 clawteam launch hedge-fund --team fund1 --goal "Analyze AAPL, MSFT, NVDA" # 代码审查团队 clawteam launch code-review --team review1 --goal "Review PR #123" ``` --- ## 总结 ClawTeam 是一个设计精巧的多智能体协调框架，其核心优势在于： ### 架构优势 1. **零依赖架构**：基于文件系统的状态存储，无需数据库或中央服务器 2. **可插拔传输层**：支持 File、P2P（ZeroMQ）、Redis 等多种传输后端 3. **多用户协作**：通过命名空间隔离支持多用户共享团队 4. **git worktree 隔离**：每个代理拥有独立的工作区，避免冲突 ### 技术亮点 1. **原子写入**：write-tmp-then-rename 模式确保数据一致性 2. **文件锁机制**：fcntl 锁确保并发安全 3. **进程存活检查**：双重检查机制准确判断代理状态 4. **智能 Prompt 注入**：使用 tmux buffer 处理多行 prompt ### 设计模式 - **策略模式**：传输层抽象 - **观察者模式**：任务依赖自动解锁 - **模板方法模式**：团队模板系统 - **互斥锁模式**：文件和任务级锁 ### 适用场景 - **自主 ML 研究**：多 GPU 并行实验 - **敏捷软件开发**：多代理并行开发 - **AI 对冲基金**：多分析师协作 - **代码审查**：多视角代码分析 ClawTeam 通过将复杂性封装在简洁的 CLI 命令背后，让 AI 代理能够自主组织、协作和收敛结果，真正实现了"你设定目标，代理群处理其余"的愿景。