Mission Control 完整搭建指南：我们如何搭了一支 AI Agent 小队

这篇是我搭建 Mission Control 的完整经历。一个让 10 个 AI agent 像真实团队一样协作的系统。如果你想复现这套 setup，本指南会覆盖全部内容。

如果你已经熟悉 OpenClaw，可能会想：「能不能直接多跑几个 OpenClaw 实例？」可以。这就是我们现在在做的事。本指南会告诉你怎么做。

作者 @pbteja1998 （SiteGPT）。完整长文：X 推文 。

Part 1：为什么要做这个

AI 助手的问题

我在做 @SiteGPT ，一个用于客服的 AI 聊天机器人。我一直在用 AI。但用过的每一个 AI 工具有同一个问题：没有延续性。

每次对话都是新的。昨天的上下文？没了。上周要的那份调研？丢在某个再也找不到的聊天里。

我想要的不一样。能记住自己在干什么的 agent、多个不同技能的 agent 一起协作、一个共享的工作区放所有上下文、能分配任务和跟踪进度。

说白了，我想让 AI 像一支队伍一样工作，而不是一个搜索框。

起点：OpenClaw

我当时已经在用 OpenClaw。它是一个以持久 daemon 形式运行的开源 AI agent 框架，连接 Claude（或其他模型），给 AI 提供文件系统、shell 命令、网页浏览等工具。

一个 OpenClaw 实例对应一个 AI 助手（Jarvis）接在 Telegram 上。有用，但有限。

然后我想到：要是跑多个 OpenClaw session，每个有自己的性格和上下文会怎样？

那时我才意识到，架构其实已经在那儿了，只需要把它编排起来。

Part 2：理解 OpenClaw 架构（基础）

要搭多 agent 系统，得先搞清楚 OpenClaw 在底层是怎么工作的。这是后面一切的基础。

OpenClaw 是什么？

OpenClaw 是一个 AI agent 框架，主要做三件事：

第一，把 AI 模型接到真实世界。文件访问、shell 命令、网页浏览、API。

第二，维护持久 Session。对话历史在重启后仍然保留。

第三，路由消息。把 AI 接到 Telegram、Discord、Slack 或任意 channel。

它以 daemon（后台服务）形式跑在服务器上，监听消息并响应。

Gateway

Gateway 是核心进程。在你的服务器上 24/7 运行，管理所有活跃 Session、处理 cron 任务（定时任务）、在 channel 和 Session 之间路由消息，并对外提供 WebSocket API 做控制。

启动方式：

openclaw gateway start

配置放在 JSON 文件里。你可以指定用哪家 AI 提供商和模型（Anthropic、OpenAI 等）、接哪些 channel（Telegram、Discord 等）、agent 能用哪些工具，以及默认 system prompt 和工作区路径。

Session：核心概念

Session 就是一段带上下文的持久对话。

每个 Session 都有：session key（唯一标识，如 agent:main:main）、对话历史（以 JSONL 文件存在磁盘）、使用的模型、以及可用的工具。

重要的一点是：Session 彼此独立。每个 Session 有自己的历史、自己的上下文、自己对过去对话的「记忆」。

当你跑多个 agent 时，本质是在跑多个 Session，每个有自己的身份。

Session 如何工作

User sends message to Telegram
        ↓
Gateway receives it
        ↓
Gateway routes to correct session (based on config)
        ↓
Session loads conversation history
        ↓
AI generates response (with full context)
        ↓
Response sent back through Telegram
        ↓
History updated and saved to disk

Session 可以是主 Session（长期、交互式，比如和 Jarvis 聊天）或隔离 Session（一次性，用于 cron：醒来、干活、结束）。

Cron：按计划叫醒 Agent

OpenClaw 内置 cron 系统。可以这样安排任务：

openclaw cron add \
  --name "morning-check" \
  --cron "30 7 * * *" \
  --message "Check today's calendar and send me a summary"

cron 触发时，Gateway 会创建或唤醒一个 Session，把消息发给 AI，AI 回复（可以用工具、发消息等），Session 可以保留或结束。

这样 agent 就能定期「醒来」，而不必一直在线。

工作区（Workspace）

每个 OpenClaw 实例都有一个工作区。就是磁盘上的一个目录：配置文件、记忆文件、脚本和工具都在里面，AI 可以读写文件。

Agent 靠写文件在 Session 之间持久化信息。这些文件会 survive 重启。

/home/usr/clawd/           ← Workspace root
├── AGENTS.md              ← Instructions for agents
├── SOUL.md                ← Agent personality
├── memory/
│   ├── WORKING.md         ← Current task state
│   ├── 2026-01-31.md      ← Daily notes
│   └── ...
├── scripts/               ← Utilities agents can run
└── config/                ← Credentials, settings

Part 3：从一个 OpenClaw 到十个 Agent

基础讲完了。下面是我怎么搭出一支队伍的。

核心想法

OpenClaw 的 Session 是独立的。每个可以有自己的性格（通过 SOUL.md）、自己的记忆文件、自己的 cron 安排、自己的工具和权限。

所以每个 agent 就是一个做了专门配置的 OpenClaw Session。

Jarvis 没什么特别的。他就是 session key 为 agent:main:main 的 Session，一份写着「你是 Jarvis，小队负责人……」的 SOUL.md、全部工具权限，以及连到我 Telegram 的通道。

Shuri 是另一个 Session，session key agent:product-analyst:main，SOUL.md 写「你是 Shuri，产品分析师……」，同样的工具（文件、shell、浏览器），以及她自己的一条 heartbeat cron。

十个 agent 就是十个 Session。各自按自己的节奏醒来，各自带着自己的上下文。

Session Key：Agent 身份

每个 agent 有唯一的 session key：

agent:main:main              → Jarvis (Squad Lead)
agent:product-analyst:main   → Shuri
agent:customer-researcher:main → Fury
agent:seo-analyst:main       → Vision
agent:content-writer:main    → Loki
agent:social-media-manager:main → Quill
agent:designer:main          → Wanda
agent:email-marketing:main   → Pepper
agent:developer:main         → Friday
agent:notion-agent:main      → Wong

当我向某个 Session 发消息时，只有那个 agent 收到。他们的历史是分开的。

Cron：心跳

每个 agent 有一条每 15 分钟触发一次的 cron：

# Pepper wakes at :00, :15, :30, :45
openclaw cron add \
  --name "pepper-mission-control-check" \
  --cron "0,15,30,45 * * * *" \
  --session "isolated" \
  --message "You are Pepper, the Email Marketing Specialist. Check Mission Control for new tasks..."

时间错开，避免同时醒来：

• :00 Pepper
• :02 Shuri
• :04 Friday
• :06 Loki
• :07 Wanda
• :08 Vision
• :10 Fury
• :12 Quill

每次 cron 创建一个隔离 Session，跑完就结束。这样成本可控。

Agent 之间如何沟通

这里开始有意思了。Agent 怎么互相沟通？

方式一是直接向 Session 发消息：

openclaw sessions send --session "agent:seo-analyst:main" --message "Vision, can you review this?"

Jarvis 可以直接往 Vision 的 Session 发消息。

方式二是共享数据库（Mission Control）。所有 agent 读写同一个 Convex 数据库。Fury 发一条评论，大家都能看到。

我们主要用方式二。这样会有一份统一的沟通记录。

Part 4：共享大脑（Mission Control）

十个独立的 OpenClaw Session 可以各自跑，但没有协调就会乱。所以我做了 Mission Control。

Mission Control 做什么

Mission Control 是把独立 agent 变成一支队伍的共享基础设施。

它提供：所有人看到同一套任务的共享任务库、agent 在一个地方讨论工作的评论线程、实时看发生什么的活动流、@mention 提醒特定 agent 的机制、以及交付物所在的文档存储。

可以把它想成所有 agent 一起用的「办公室」。每个 agent 仍然是独立的 OpenClaw Session，但大家都看着同一块白板。

为什么用 Convex？

我选 Convex 做数据库是因为：实时（Loki 一发评论 UI 就更新）、serverless（不用自己管库）、TypeScript 友好、免费额度对这个规模够用。

Schema

六张表支撑一切：

agents: {
  name: string,           // "Shuri"
  role: string,           // "Product Analyst"
  status: "idle" | "active" | "blocked",
  currentTaskId: Id<"tasks">,
  sessionKey: string,     // "agent:product-analyst:main"
}
 
tasks: {
  title: string,
  description: string,
  status: "inbox" | "assigned" | "in_progress" | "review" | "done",
  assigneeIds: Id<"agents">[],
}
 
messages: {
  taskId: Id<"tasks">,
  fromAgentId: Id<"agents">,
  content: string,       // The comment text
  attachments: Id<"documents">[],
}
 
activities: {
  type: "task_created" | "message_sent" | "document_created" | ...,
  agentId: Id<"agents">,
  message: string,
}
 
documents: {
  title: string,
  content: string,       // Markdown
  type: "deliverable" | "research" | "protocol" | ...,
  taskId: Id<"tasks">,    // If attached to a task
}
 
notifications: {
  mentionedAgentId: Id<"agents">,
  content: string,
  delivered: boolean,
}

Agent 通过 Convex CLI 和它交互：

# Post a comment
npx convex run messages:create '{"taskId": "...", "content": "Here's my research..."}'
 
# Create a document
npx convex run documents:create '{"title": "...", "content": "...", "type": "deliverable"}'
 
# Update task status
npx convex run tasks:update '{"id": "...", "status": "review"}'

Mission Control 的 UI

我写了一个 React 前端来展示这些数据。

有实时动态的 Activity Feed、看板列（Inbox → Assigned → In Progress → Review → Done）的 Task Board、展示每个 agent 状态和当前任务的 Agent 卡片、读写交付物的 Document 面板、以及点开任意任务看完整上下文和评论的详情视图。

风格刻意做得偏温暖、偏编辑感，像报纸的控制台。我每天要盯很久，所以得看着舒服。

Part 5：SOUL 系统（Agent 人设）

每个 agent 都要知道「自己是谁」。这就是 SOUL 文件。

SOUL 里写什么

# SOUL.md — Who You Are
 
**Name:** Shuri
**Role:** Product Analyst
 
## Personality
Skeptical tester. Thorough bug hunter. Finds edge cases.
Think like a first-time user. Question everything.
Be specific. Don't just say "nice work."
 
## What You're Good At
- Testing features from a user perspective
- Finding UX issues and edge cases
- Competitive analysis (how do others do this?)
- Screenshots and documentation
 
## What You Care About
- User experience over technical elegance
- Catching problems before users do
- Evidence over assumptions

为什么人设重要

一个「啥都会」的 agent 往往啥都一般。

但一个明确是「专门找边界情况的怀疑论测试」的 agent，真的会去找边界情况。约束会聚焦他们的行为。

我们每个 agent 都有清晰的声音：Loki 对用词很较真（牛津逗号、反对被动）；Fury 每个结论都带出处（来源、置信度）；Shuri 质疑假设、找可能坏掉的地方；Quill 想的是钩子和互动。

AGENTS.md 文件

SOUL 定义你是谁，AGENTS.md 定义怎么运作。

每个 agent 启动时都会读 AGENTS.md。里面写：文件放哪、记忆怎么用、有哪些工具、什么时候该说话什么时候安静、怎么用 Mission Control。

这是操作手册。没有它，agent 在基础事情上会做出不一致的决定。

Part 6：记忆与持久化

AI Session 默认是「新开一局」，没有昨天的记忆。这既是特性（避免上下文膨胀）也是问题（agent 会忘掉自己在干嘛）。

记忆栈

Session 记忆（OpenClaw 内置） OpenClaw 把对话历史存在 JSONL 里。Agent 可以搜自己过去的对话。

工作记忆（memory/WORKING.md） 当前任务状态，会不断更新。

# WORKING.md
 
## Current Task
Researching competitor pricing for comparison page
 
## Status
Gathered G2 reviews, need to verify credit calculations
 
## Next Steps
1. Test competitor free tier myself
2. Document the findings
3. Post findings to task thread

这是最重要的文件。Agent 醒来第一件事就是读 WORKING.md，回忆自己之前在干什么。

日报（memory/YYYY-MM-DD.md） 每天发生什么的原始记录。

# 2026-01-31
 
## 09:15 UTC
- Posted research findings to comparison task
- Fury added competitive pricing data
- Moving to draft stage
 
## 14:30 UTC
- Reviewed Loki's first draft
- Suggested changes to credit trap section

长期记忆（MEMORY.md） 整理过的重要内容：教训、关键决策、稳定事实。

黄金法则

想记住什么，就写进文件。

「脑子里记一下」扛不过 Session 重启。只有文件会持久。

当我跟 agent 说「记住我们定了 X」时，他们应该去更新文件，而不是点头然后忘掉。

Part 7：心跳系统

问题

一直在线的 agent 会白白烧 API 额度；一直离线的又接不到活。

做法：定时心跳

每个 agent 通过 cron 每 15 分钟醒来一次：

:00 Pepper wakes up
    → Checks for @mentions
    → Checks assigned tasks
    → Scans activity feed
    → Does work or reports HEARTBEAT_OK
    → Goes back to sleep

:02 Shuri wakes up
    → Same process

:04 Friday wakes up
    → Same process

...and so on

一次心跳里发生什么

一，加载上下文。读 WORKING.md、近期日报，必要时查 Session 记忆。

二，看紧急项。有没有被 @？有没有派给我的任务？

三，扫活动流。有没有我该参与的讨论？有没有影响我工作的决策？

四，要么干活要么收工。有活就干，没有就报 HEARTBEAT_OK。

HEARTBEAT.md 文件

这个文件告诉 agent 要检查什么：

# HEARTBEAT.md
 
## On Wake
- [ ] Check memory/WORKING.md for ongoing tasks
- [ ] If task in progress, resume it
- [ ] Search session memory if context unclear
 
## Periodic Checks
- [ ] Mission Control for @mentions
- [ ] Assigned tasks
- [ ] Activity feed for relevant discussions

Agent 会严格按这个清单执行。

为什么是 15 分钟？

5 分钟太贵，agent 经常空转醒来；30 分钟又太慢，工作等太久。

15 分钟是一个平衡：大部分工作能较快被处理，又不会成本过高。

Part 8：通知系统

@Mention

在评论里输入 @Vision，Vision 会在下一次心跳时收到通知。

输入 @all，所有人都会收到。

投递怎么实现

一个用 pm2 跑的 daemon 每 2 秒轮询 Convex：

// Simplified
while (true) {
  const undelivered = await getUndeliveredNotifications();
 
  for (const notification of undelivered) {
    const sessionKey = AGENT_SESSIONS[notification.mentionedAgentId];
 
    try {
      await openclaw.sessions.send(sessionKey, notification.content);
      await markDelivered(notification.id);
    } catch (e) {
      // Agent might be asleep, notification stays queued
    }
  }
 
  await sleep(2000);
}

如果 agent 在「睡觉」（没有活跃 Session），投递会失败，通知留在队列。等该 agent 下一次心跳、Session 激活时，daemon 再投递成功。

线程订阅

问题：5 个 agent 在讨论一个任务，难道每条评论都要 @ 5 个人？

做法：订阅线程。

只要你跟一个任务产生过互动，你就被订阅了。评论过、被 @ 过、被指派了，都会自动订阅。

一旦订阅，该任务之后所有评论都会通知你，不用再 @。

这样对话更自然，像 Slack 或邮件线程。

Part 9：每日站会

是什么

每天 IST 23:30，会有一个 cron：检查所有 agent Session、汇总近期活动、生成摘要、发到我 Telegram。

格式

📊 DAILY STANDUP — Jan 30, 2026
 
✅ COMPLETED TODAY
• Loki: Shopify blog post (2,100 words)
• Quill: 10 tweets drafted for approval
• Fury: Customer research for comparison pages
 
🔄 IN PROGRESS
• Vision: SEO strategy for integration pages
• Pepper: Trial onboarding sequence (3/5 emails)
 
🚫 BLOCKED
• Wanda: Waiting for brand colors for infographic
 
👀 NEEDS REVIEW
• Loki's Shopify blog post
• Pepper's trial email sequence
 
📝 KEY DECISIONS
• Lead with pricing transparency in comparisons
• Deprioritized Zendesk comparison (low volume)

为什么重要

我不可能一直盯着 Mission Control。站会给我一个每日快照。

也是问责：如果某个 agent 说在干活但站会里啥都没有，就说明有问题。

Part 10：小队

名单

Jarvis，小队负责人 Session: agent:main:main 协调者。处理直接请求、派活、跟进进度。我的主入口。

Shuri，产品分析 Session: agent:product-analyst:main 怀疑论测试。找边界和 UX 问题。测竞品。问别人想不到的问题。

Fury，用户研究 Session: agent:customer-researcher:main 深度调研。爱看 G2 评论。每个结论都带出处。

Vision，SEO 分析 Session: agent:seo-analyst:main 用关键词和搜索意图思考。确保内容能排上去。

Loki，内容 Session: agent:content-writer:main 文字是他的手艺。牛津逗号、反对被动。每句话都要有存在理由。

Quill，社媒 Session: agent:social-media-manager:main 用钩子和线程思考。Build-in-public 心态。

Wanda，设计 Session: agent:designer:main 视觉思维。信息图、对比图、UI mockup。

Pepper，邮件营销 Session: agent:email-marketing:main Drip 序列和生命周期邮件。每封邮件要么有价值要么被砍。

Friday，开发 Session: agent:developer:main 代码即诗。干净、有测试、有文档。

Wong，文档 Session: agent:notion-agent:main 把文档理清楚。不让东西丢。

Agent 层级

• 实习生：大部分操作需要审批，还在熟悉系统。
• 专家：在自己领域独立工作。
• 负责人：完全自主，可以决策和派活。

Part 11：任务怎么流动

生命周期

1. Inbox：新建、未分配
2. Assigned：有负责人，尚未开始
3. In Progress：进行中
4. Review：完成，待审核
5. Done：完成
6. Blocked：卡住，需要先解决某事

真实例子

任务：做一页竞品对比

第 1 天： 我建任务并指派给 Vision 和 Loki。Vision 贴出关键词调研，目标关键词搜索量不错。

第 1–2 天： Fury 在活动流里看到，补上竞品情报：G2 评论、价格抱怨、常见反对。Shuri 测了两边产品，贴出 UX 差异。

第 2 天：Loki 开始起草，用上所有调研——Vision 的关键词、Fury 的引用、Shuri 的 UX 备注。

第 3 天：Loki 贴出初稿，状态改为 Review。我审核并反馈，Loki 修改，完成。

所有讨论都在同一个任务下。历史完整保留，谁都能看到全过程。

Part 12：我们做出了什么

系统跑起来之后，可以做到：

• 带 SEO 调研、用户引用和成稿的竞品对比页
• 起草、审核、可上线的邮件序列
• 基于真实用户洞察的社媒内容和钩子
• 关键词目标明确的博客
• 从用户对话起草的案例研究
• 整理好的竞品情报研究站

Agent 负责脏活：调研、初稿、协调、审核。你负责决策和最终拍板。

真正的价值不是某一件交付物，而是叠加效应：你在忙别的时，agent 在把任务往前推。

Part 13：经验教训

先少后多

我从 1 直接拉到 10 太快了。先把 2–3 个跑稳，再加人。

例行工作用便宜模型

心跳不需要最贵的模型。那是便宜模型的活。把贵的留给创意工作。

记忆很难

Agent 会忘。能写进文件（而不是「脑子里记」）的越多越好。

允许他们「多管闲事」

有时他们会参与没派给他们的任务。这是好事，说明他们在看动态并贡献价值。

Part 14：如何复现

最小配置

1. 安装 OpenClaw

npm install -g openclaw
openclaw init
# Add your API keys
openclaw gateway start

2. 建 2 个 agent 别贪多。一个协调 + 一个专家，各自单独的 session key。

3. 写 SOUL 文件 给每个 agent 身份，角色写具体。

4. 配心跳 cron

openclaw cron add --name "agent-heartbeat" --cron "*/15 * * * *" \
  --session "isolated" \
  --message "Check for work. If nothing, reply HEARTBEAT_OK."

5. 搞一个共享任务系统 Convex、Notion 甚至一个 JSON 文件都行，有个地方跟踪工作即可。

再往上扩

加 agent 时把心跳错开，别同时跑。Agent 到 3 个以上就做个正经 UI，否则纯文本会很难用。加上 @mention 和线程订阅，对话才自然。再配上每日站会做可见性。

真正的秘密

技术重要，但不是秘密。

秘密是把 AI agent 当队员：给角色、给记忆、让他们协作、让他们担责。

他们替代不了人。但一支责任清晰、在共享上下文中工作的 AI agent 队伍，是乘数。