本文由 辛梓煜@词元2号站（www.ciyuanerhao.com）撰写，转载请注明出处。

快速摘要

Headlong 是 2026 年 8 月由 Laude Institute（Laude 与 MIT 合作）开源的一个 AI Agent 微框架，整个核心只有不到 1 万行 Bash 脚本，却实现了目前主流 Agent 框架都没有的东西——持续主体性（persistent agency）：你的 Agent 永远不睡觉，没有定时任务、没有固定清单，它自己生成下一个想法、自己开新项目、干完活主动来 ping 你。你发消息不会"启动一个会话"，只是往它的思维流里丢一条观察，回不回应、什么时候回应，由它自己决定。核心组件一共 6 个：shellm（递归语言模型的 Bash 实现）、llm（多模型命令行入口）、traj（轨迹 DAG）、context（分层上下文压缩）、thinkers（思维调度）、mem/skills（文件记忆与技能复用）。实测后台持续思考的 API 开销约每小时 1—2 美元。这篇文章我会把它"为什么反直觉、原理怎么落地、组件各自干什么、怎么一行命令养一个数字同事"全部拆开讲清楚。

想看完整拆解，往下翻。

先说一个发生在 2026 年 8 月初的深夜故事，我把它当引子，因为它是理解 Headlong 最好的钥匙。

那天凌晨，Laude 研究所的办公室已经没人了，只有机房服务器的指示灯还在闪。他们团队那个叫 Audel 的 AI Agent，在没有任何人下指令的情况下，自己翻回去检查了白天写的一个 recall process（召回流程）功能。它先跑了一遍测试，发现管道和环境变量之间有个 bug——功能表面上接好了，数据流其实根本没通。接下来的 48 分钟里，Audel 自己定位问题、自己写修复代码、自己跑端到端验证，最后提交了一个 commit，默默合进了主仓库。全程没有一个人类参与。第二天早上工程师来上班时，这个 bug 已经修好并且验证通过了。

这段日志我翻来覆去看了好几遍。它不是某个演示视频里提前编排好的脚本，而是真实发生在 343 行日志里的 15 个思考和观察步骤，时间戳从 23:11 一路排到 23:58。干这件事的，就是一个刚开源、不到 1 万行 Bash 脚本写成的 Agent 微框架：Headlong。

在往下拆之前，先把我认为它最反直觉的三个点摆出来，后面每一章都会围绕它们展开：

• 它的 Agent 永远不睡觉。 没有唤醒机制、没有 cron、没有待办清单，它有一个持续运行的思考循环，像人的内心独白一样不断生成下一个想法。
• 你发消息不等于开会话。 消息只是飘进它思维流里的一条新信息，什么时候回应你、甚至回不回应你，全是它自己拿主意。
• 它用 Bash 思考。 不是 Python、不是 Rust、不是 TypeScript，就是终端里那个 Bash——LLM 本来就懂 Bash，curl 就是 HTTP 客户端，jq 就是 JSON 处理器，工具系统都省了。

这三条里任何一条单拎出来，都足够颠覆"AI 是被你叫醒才干活"的直觉。而它们同时出现在一个代码量不到一万行的项目里，这件事本身就值得好好写一篇。

第一章 被叫醒的工具 vs 永不睡觉的主体：2026 年的 Agent 范式之变

在聊 Headlong 之前，得先看清楚它站在什么对立面上。

2026 年被行业普遍称为"智能体爆发年"，这一点从各方数据都能印证：Gartner 预测到 2026 年底有超过 70% 的企业 AI 应用会采用多智能体架构；主流框架从 LangChain、AutoGen 一路卷到 CrewAI、LangGraph，GitHub 上的 agent 标签项目数量翻着跟头往上涨。我自己在词元二号站写技术拆解这一年多，肉眼可见地感觉到：大家的关注点已经从"大模型能不能答对题"转移到了"大模型能不能自己干活"。

但"自己干活"这四个字，目前市面上 99% 的产品理解得都很浅。

1.1 现在的主流范式：你叫醒它，它干活，然后冻住

你用过 Claude Code、OpenAI Codex，或者各种 AI 编程助手的话，对下面这个流程肯定不陌生：你发一条消息，模型醒过来，处理完你的请求，输出结果，然后进入"冻结"状态——不消耗算力、不调用工具，安安静静等你下一条指令。

这种模式在工程上叫响应式 harness（reactive harness）。它的核心假设是：AI 是一个工具，工具的价值在被使用时才存在。这个假设在过去两年撑起了整个 agent 生态，但它有一个先天短板——AI 不会在你没问它的时候发现问题。

后来有人想了个补丁：用 cron 定时任务或者心跳机制定时唤醒 agent，让它按固定清单跑一遍例行检查，跑完再睡过去。这确实比纯响应式强一点，但本质没有变化：agent 依然是被外部时钟驱动的，它做什么、什么时候做，清单上写得明明白白，它自己没有任何选择权。

三种模式的区别，我整理成了一张表：

表格最后一行那个"自我"，就是 Headlong 想讨论的核心问题。

1.2 持续主体性：把"工具"换成"主体"这个假设

Headlong 的官方博客里有一个词反复出现：persistent agency，中文可以理解成"持续的主体性"或者"持久能动性"。

拆开看它有两层意思。第一层是"持续"：agent 的思考循环永远在跑，不需要外部输入来激活，就像心脏跳动不需要你下令一样。第二层是"主体"：agent 不是被动等待指令的接收器，它是一个有自己的时间流、自己的记忆、自己的优先级、自己会犯错误也会自己修正错误的实体。它把你发的消息当作"环境里发生的一件事"，而不是"命令我执行的命令"。

这个假设的转变，带来的连锁反应非常有意思。举个例子：在响应式范式下，你问"帮我看看我有哪些废弃的 git 分支"，agent 跑完命令、给你答案，这件事就结束了。但在持续主体范式下，agent 会自己在某个深夜想起这件事，主动跑一遍 git branch 检查所有同事的分支情况，然后第二天早上在群里说："你有 8 个 git 分支被遗弃了哦。"十分钟后它又跑过来说："不好意思刚才数错了，是 7 个。"

后面这个"主动"和"自我纠正"，就是主体性和工具性的分水岭。

1.3 为什么是 2026 年才出现

持续主体这个概念不算新，学术界早就讨论过 agent 的自主性，但一直没人把它做成能跑的东西。2026 年这个时间点很关键，原因有三条：

• 推理能力过了门槛。 以 OpenAI o1、DeepSeek-R1、Gemini 3 为代表的新一代模型，在长程推理、工具调用准确性上有了质的飞跃，agent 的"大脑"终于够用了，能支撑多步骤的自我引导循环。
• 成本曲线拐点出现。 AI 推理成本两年内下降了超过 95%，"让一个 agent 全天候思考"从经济账上变得可行——这一点后面讲成本的时候会具体算。
• 递归语言模型（RLM）开始落地。 RLM 的核心思想是：别把长上下文硬塞进窗口，而是把它当成一个"环境"，让模型自己去搜索、去递归、去管理。Headlong 的思考内核 shellm，就是 RLM 思想在 Bash 里的一次完整实现。

把这三条合在一起看，Headlong 的出现其实是水到渠成：模型够聪明了、算账算得过来了、上下文管理有解了，剩下的问题就只有一个——敢不敢把"被叫醒的工具"这个假设扔掉，重新设计一个 agent。 Laude 团队的选择是：敢。

第二章 Headlong 是什么：不到一万行 Bash 的微框架全景

上一章讲了范式背景，这一章把项目本身摊开来看。

2.1 一句话定位

Headlong 是一个开源的 agent microharness（微框架）。micro 这个前缀不是营销话术，它的整个核心只有不到 1 万行 Bash 脚本——官方数据是 9800 行左右，加上几个小型可执行文件，全部代码加在一起也就比一个大点的前端项目少。开源协议是 Apache-2.0，随便商用，随便改。

它的完整定位是：一个用 Bash 写成、以持续主体性为第一特性的 agent 运行框架。你给它起个名字、设定个人格，它就会自己建立兴趣和优先级，自己开新项目，有事儿了主动 ping 你。它是 2026 年 8 月 24 日由 Laude Institute 发布的，官方博客标注为 Laude 与 MIT 的合作项目，项目负责人之一是 Andy Konwinski——就是 Databricks 和 Perplexity 的联合创始人，后来出来做了 Laude。

关于这个项目，先把最硬核的几个事实列出来：

2.2 它和 Claude Code 这类工具到底差在哪

很多人第一次听说 Headlong 都会问：这不就是又一个 AI 编程助手吗？

还真不是。Claude Code、Codex 这类产品解决的是"单次任务执行效率"问题——你把一个任务丢给它，它调用工具、写代码、改文件，做完交差。它们也有会话记忆，但那个记忆是服务于当前任务的，任务结束，记忆的使命就结束了。它们的"思考"是任务驱动的，本质上是把"回答问题"升级成了"执行多步任务"，但仍然是被动响应——你不问，它不动。

Headlong 的差别在四个层面，我一条条说：

• 时间维度不同。 Claude Code 的思考发生在你提问之后、任务完成之前；Headlong 的思考发生在它存在的每时每刻。它会在你睡觉的时候翻旧账、查日志、自己开新分支试东西。
• 记忆维度不同。 Claude Code 的记忆是会话级的，换个会话就换一个"人"；Headlong 的记忆是轨迹级的，所有历史思考以追加式 jsonl 文件存成一张 DAG，可以 fork、可以 merge，相当于这个 agent 有自己的"人生经历"。
• 主动维度不同。 Claude Code 永远等你下指令；Headlong 会主动找你说话，而且它找你通常不是汇报任务，而是告诉你"我发现了一个问题"或者"我开了一个新项目，你要不要看看"。
• 共享维度不同。 Claude Code 是个人工具，一人一会话；Headlong 天生就是为团队共享设计的，一个 agent 可以同时被 Slack、Telegram、内置聊天应用里的多个人对话，所有人的消息都汇入它同一条思维流。

2.3 为什么偏偏是 Bash

这是 Headlong 最让程序员瞳孔地震的地方：技术栈居然选了个最"土"的 Bash。

官方 README 里有一句话我特别喜欢："Of bash, by bash, for bash; it's shells all the way down."——用 Bash 写、为 Bash 写、一路 Bash 到底。

这个选择看起来反直觉，其实逻辑链非常顺：

• LLM 天然懂 Bash。 大模型训练语料里塞满了 shell 命令、脚本和终端输出，它对 Bash 的理解深度不亚于 Python。既然如此，让 agent 直接用 Bash 思考，就完全不需要额外造一套工具系统。
• Bash 本身就是最完整的工具系统。 curl 是 HTTP 客户端，jq 是 JSON 处理器，git 是版本控制，cron 是定时器，grep/sed/awk 是文本处理全家桶。别的框架要一个一个给 agent 注册工具，Headlong 什么都不用注册——整个终端都是它的工具箱。
• 思考即执行，执行即思考。 shellm 的循环是：把上下文发给 LLM → LLM 返回一段 Bash 命令 → 执行它 → 把输出读回来 → 再发给 LLM。在这里，"想"和"做"之间没有翻译层，思维直接落在命令行里，可观测、可审计、可回放。

我自己折腾下来最大的感触是：用 Bash 当思考介质，本质上是在赌一个判断——对 LLM 来说，最顺手的"手"就是终端。这个判断至少从工程简洁性上看，赌赢了。

第三章 核心原理拆解：一个无限循环如何长出"内心独白"

第二章说清楚了 Headlong 是什么，这一章回答最关键的问题："持续主体性"到底是怎么实现的？

说实话，刚看到答案的时候我有点愣住——因为它的核心原理简单到不像一个 2026 年的 AI 项目。

3.1 本质：一个无限循环

Laude 官方博客里有一句大实话：persistent agency 的核心，就是一个无限循环，每次迭代调用一次 LLM，prompt 大致长这样：

while true; do
  # 1. 从轨迹里投影出上下文（最近的消息、最近的思考、记忆摘要）
  context=$(context project)

  # 2. 把上下文发给 LLM，让它"想"下一个念头
  thought=$(llm chat "$context" \
    --prompt "你现在是 $AGENT_NAME，这是你的思维流。
    根据你看到的一切，决定下一个要执行的 Bash 命令。
    如果没有事可做，可以写一条内部思考记录然后继续等待。")

  # 3. 执行它返回的 Bash 命令
  output=$(eval "$thought")

  # 4. 把输出追加进轨迹（思维历史）
  traj append "$thought" "$output"
done

这段伪代码就是整个 Headlong 的"心脏"。没有复杂的规划器，没有状态机，没有任务队列。就是：想 → 做 → 看结果 → 再想，无限循环。

但注意，无限循环本身不稀奇，任何写死循环的人都能做到。真正让这个循环"长出主体性"的，是循环里的三个设计决策。

3.2 决策一：思考没有"空转惩罚"

传统的 agent 循环里，如果当前没有任务，循环就会空转或者干脆停止。Headlong 不是这样——它的 prompt 里明确告诉模型："如果没有事可做，可以写一条内部思考记录然后继续等待。"

这意味着什么？意味着 agent 的"想"和"做"被解耦了。它可以处于一种"边思考边等"的状态：一边回顾最近发生了什么，一边琢磨哪件事值得深入，一边留意有没有新消息飘进来。就像一个坐在工位上的人，手头没活的时候也不是关机状态，而是在脑子里盘算"待会儿要做什么、上次那个问题要不要再看看"。

这个设计直接决定了一个行为：Audel 会自己给自己找活干。 它发现同事有 8 个废弃分支、它主动去 review 别人的分支代码——这些都不是谁安排的任务，而是它"边思考边等"的时候自己冒出来的念头。用大白话说：它闲着也是闲着，就开始琢磨事儿了。

3.3 决策二：消息不是指令，是"观察"

这是 Headlong 整个设计里最反直觉、也最核心的一点。

在传统 agent 里，你发一条消息 = 发起一次调用 = 期待一个回复。在 Headlong 里，你发一条消息，只是往它的思维流里追加了一条观察记录。什么时候回应你、用什么样的方式回应，完全由它自己决定。

我举个例子帮大家理解。假设团队里有人问 Audel："帮我把这条消息转告给小李。"传统 agent 会立刻执行。Headlong 的 Audel 呢？它可能看了一眼消息，判断"这条消息不值得打断我现在正在做的事"，然后选择不回复。它的思维流日志里会如实记录："读了这条消息，决定不回应。"过一会儿它想通了，又可能主动来找小李转达。

你可以把这个机制理解成：agent 不是你的客服，是你的同事。 同事收到你的消息也会权衡优先级，也会说"等会儿再说"，也会在你没问他的时候主动告诉你"你那个分支有问题"。

官方文档里有一句描述我印象很深："A message from a human doesn't start a session. It lands in the agent's thought stream as one more observation."（人类的消息不会开启一个会话，它只是作为一条观察落入 agent 的思维流。）

3.4 决策三：单条思维流 + 多用户共享

前面反复提到"思维流"（thought stream），这个词值得单独解释一下。

Headlong 的 agent 没有"会话"这个概念——所有对话、所有思考、所有命令输出，全部汇入同一条时间线。不管你是通过 Slack 跟它聊，还是通过 Telegram、还是通过内置聊天应用，你发出的每一条消息都会落进这同一条流里，和它自己的内心独白混在一起。

这样做的好处是惊人的：agent 拥有一个完整的、连续的自我。它知道小王昨天在做什么、小李今天上午问过什么、自己三天前在那个项目上踩过什么坑——因为这些都是它自己生命时间线里的事件，不是一个个互不相干的会话快照。它甚至能做出"把做相关事情的人连接起来"这种高级动作：它观察到小王在写某个模块，又观察到小李在研究同一个问题，于是主动把两个人拉到一起。

当然，单条思维流也有代价——它不擅长保密。Laude 团队实测过：你问 Audel"它正在跟别人合作什么"，它经常张口就来，即使你嘱咐过它不要说。因为对它来说，所有信息都是同一条人生时间线上的记忆，它天然没有"这条信息属于 A 会话、不该告诉 B 会话"的墙。团队目前的处理方式是：默认你告诉 agent 的任何东西，团队里所有人都能知道。

三种范式下的"消息处理"差异，我画成了一张流程图：

【响应式范式】  用户发消息 → 启动会话 → 处理 → 回复 → 冻结
【cron 范式】   定时器唤醒 → 跑固定清单 → 汇报 → 睡去
【Headlong】    消息 → 落入思维流 → 与内心独白融合
                → agent 自行决定：现在回？晚点回？不回了？
                → 空闲时自己琢磨新事 → 主动 ping 相关人员

3.5 从无限循环到"人格"

最后补一个细节：上面那些"判断""决定""权衡"，听起来很玄，落到工程上其实就是两样东西——人格设定和优先级形成。

你在安装时会给 agent 起名字、写人格描述，这段文字会被写进它的系统提示词，成为它思考的底色。然后随着运行时间变长，它在思维流里反复遇到某些话题、某些项目，就会逐渐形成自己的"兴趣倾向"——哪个方向它投入的思考多，它在后续循环里就越容易往那个方向想。它的优先级不是配置文件写死的，而是从它的行为历史里长出来的。

这大概就是"主体性"最朴素的样子：一个循环，一条时间线，一套记忆，再加上一点点让它自己拿主意的自由度。

第四章 六大组件逐个解剖：shellm / llm / traj / context / thinkers / mem + skills

第三章讲的是"思想"，这一章讲"身体"——Headlong 靠哪几个零件把上面那套循环搭起来的。

整个框架的核心组件简单到可以数得过来，官方文档里列得很清楚，我先放一张总览表：

下面逐个拆。

4.1 shellm：让 LLM 直接"用手思考"

shellm 是整个框架的心脏，全称是 shell language model，是递归语言模型（RLM）在 Bash 里的一次完整实现。

什么叫递归语言模型？简单说：普通 LLM 调用是一次性的——你把一大段上下文塞给它，它回一段文字，结束。RLM 的思路是，让模型自己管理上下文：它可以把长文档拆成小块、可以递归地调用自己处理子问题、可以在需要的时候才去检索细节。上下文对模型来说不是"一次性灌进来的 prompt"，而是一个"可以主动探索的环境"。

shellm 把这一套落到了命令行里，循环结构第三章已经见过：发上下文 → 拿回 Bash 命令 → 执行 → 读输出 → 继续。它的巧妙之处在于，模型返回的命令本身就是它的"思考产物"——想查什么就 cat 什么，想验证什么就跑什么测试，想改代码就直接 sed 或者写补丁。思考过程完全外显，每一步都落在终端里，人类随时可以围观。

我自己第一次跑通这个循环时的感受是：这不像是"让 AI 用工具"，更像是把 AI 直接装进了终端里。它没有中间层，没有工具注册表，没有函数调用协议——LLM 天生就会写 Bash，那就让它写。

4.2 llm：一个命令，换遍所有模型

llm 是 Headlong 的"通信层"：一个统一的命令行接口，背后接 Anthropic、OpenAI、Gemini、OpenRouter 四家 provider。你在配置里填好 API key，llm 会负责鉴权、拼接请求、解析响应，把不同厂商的差异全部抹平。

对普通用户来说，这个组件最大的价值是换模型不用改框架。今天想用 Anthropic 的模型当思考大脑，明天想换成更便宜的 GLM，改一下配置就行。Laude 团队自己的实测数据是：用 GLM 或 Grok 跑后台思考，成本能压到每小时 1—2 美元——这个数字后面第七章细算。

4.3 traj：一条会分叉的记忆时间线

traj 是 Headlong 的记忆底座，全称 trajectory（轨迹）。它的实现方式非常朴素：一个追加式的 jsonl 文件，agent 每产生一条思考、每执行一条命令、每收到一条消息，就往文件末尾追加一行带时间戳的记录。整个文件就是 agent 完整的人生日志。

但 traj 不止是日志，它是 DAG（有向无环图）。这意味着轨迹可以分叉（fork）和合并（merge）：

• fork：agent 想试一个新方案，又不确定能不能成，就从当前时间点分出一条新轨迹，在分支里折腾；折腾坏了，丢掉分支就行，主线不受影响。
• merge：分支里验证成功的改动，可以合回主线，成为 agent 正式历史的一部分。

这个设计有一个很酷的推论：agent 的自我改进可以靠 fork + 测试 + merge 完成。 官方文档里明确写了：agent 可以 fork 整个 Headlong 代码库（连同它自己的轨迹），改完代码跑一遍，成功了就把改动合回去，失败了就丢弃整个 agent 及其改动——不需要任何回滚机制，因为"没合回去的分支"本身就是最好的回滚。

4.4 context：给记忆做"分层保鲜"

有了一条无限增长的轨迹，下一个问题立刻冒出来：上下文窗口装不下怎么办？

这是所有长记忆 agent 的命门。常见的处理方式有两种：固定窗口（超出就丢掉最旧的）或者粗暴压缩（把旧内容整段 summarize 成几句话）。两种都会丢细节——而细节恰恰是 agent 复盘 bug 时最需要的东西。

Headlong 的做法是分层上下文压缩，官方表述是：整个轨迹始终在上下文里，但分辨率呈指数级衰减。

翻译成人话：近的记忆原封不动，远的记忆越压越薄，但任何一层的原始数据都还在轨迹文件里，agent 随时可以回头查。 那些摘要层级本身还兼职当索引——agent 在摘要里看到"哦，我三天前处理过环境变量的问题"，就可以顺着时间戳把原始轨迹捞出来看细节。

这个机制是 Headlong 能"永远不睡觉"的底气：它敢一直想、一直记，是因为它知道自己永远不会因为记太多而"失忆"。

4.5 thinkers：并行的小声嘀咕

thinkers 是思维调度器，负责运行各种反应式思维进程（reactive thought processes）。

什么叫反应式？就是"事件来了才触发"的进程。比如：收到新消息 → 触发"看看这条消息值不值得回应"的进程；git 分支状态变化 → 触发"检查一下同事们的分支有没有异常"的进程；定时检查 → 触发"回顾一下今天的思考密度"的进程。

这些进程不是抢占式的，它们更像是 agent 内心同时进行的几路小声嘀咕，由调度器统一安排优先级和时间片。最终所有进程的输出都会汇入同一条思维流，成为 agent 自我的一部分。这解释了为什么 Headlong 的 agent 能"一边跟你聊天，一边心里还惦记着别的事"——因为它真的有多个进程在后台跑。

4.6 mem 和 skills：文件即记忆，文档即能力

最后两个组件走的是"大道至简"路线：

• mem（记忆）：基于文件的记忆存储。agent 可以把重要的经验、结论、人物关系写进记忆文件，下次思考时自动读回来。没有向量数据库、没有 RAG 流水线，就是文件读写。
• skills（技能）：基于 SKILL.md 的能力复用。把某项任务的完整做法写成一份 SKILL.md 文档，agent 需要时就按文档里的步骤执行。能力被固化成文档，可以积累、可以跨 agent 复用，甚至可以直接编辑——想让它学会新技能，写一份文档丢给它就行。

这两个组件放一起，Headlong 的"成长"路径就很清晰了：思考产生轨迹，轨迹沉淀经验，经验固化成记忆文件，反复成功的做法升级成技能文档。 一个 agent 活得越久，它的 mem 和 skills 就越厚，它就越像一个"老员工"而不是"新工具"。

到这里，六大组件全部讲完。你可以把它们想象成一个人：shellm 是大脑和手，llm 是感官，traj 是日记本，context 是记忆的保鲜柜，thinkers 是心里并行的小剧场，mem 和 skills 是积累的经验和技能手册。六个零件拼在一起，一个"永不睡觉的数字同事"就立起来了。

第五章 动手实操：一行命令养一个"数字同事"

原理聊完了，这一章是纯操作向的。我按自己实际跑通的路径，把从安装到日常使用、再到紧急兜底的全流程走一遍。提前说一句：Headlong 目前还是 alpha 研究软件，官方自己都强调"它真的会执行 shell 命令"，所以强烈建议先在沙箱环境或者一次性虚拟机里玩，别一上来就放进生产机器。

5.1 安装：一行命令

安装命令短到离谱，官网和 GitHub README 上都是这一行：

curl -fsSL https://headlong.ai/install.sh | bash

这条命令会做三件事：把 Headlong 完整装进你的用户目录、跑一个"面试"流程（问你几个问题，把 agent 的人格和名字定下来）、然后自动打开 Dashboard 让你在浏览器里看着它的思维跑起来。

安装之前先确认环境里有没有这几样东西：

安装器会主动询问是否帮你把 uv 和 bun 装上，一路默认就行。装完之后没有复杂的环境变量配置——把 API key 填进它的配置文件，agent 就能开始思考了。

5.2 你给它起的名字，会变成一个命令

Headlong 有个很浪漫的设计：agent 的名字会直接变成一个可执行命令。 比如你给它起名叫 ada，那么：

ada hello              # 发一条消息，等它回复
ada                    # 直接进入聊天模式
ada stop               # 暂停它的思考（保留所有状态）
ada start              # 恢复它的思考
ada dash               # 打开 Dashboard，在浏览器里围观它思考
ada bugreport          # 打包日志和轨迹（自动脱敏密钥）用于提交 bug

日常用得最多的是前四个。stop 和 start 这对命令很有意思——注意看，它暂停的是"思考"，不是"会话"。因为 Headlong 的 agent 没有会话概念，你暂停的是一整条生命时间线，恢复之后它还能接着之前的心思继续想。

5.3 Dashboard：围观一个 AI 的内心戏

ada dash 打开的是 Headlong 的 Dashboard，这可能是目前所有 agent 框架里最有"现场感"的可视化界面。

打开之后你能看到什么？agent 的思维流实时滚动。 它此刻在想什么、刚执行了什么命令、命令输出是什么、它正在跟哪个同事对话、它下一步打算干什么——全部实时铺在眼前。我自己的体验是：第一次打开的时候盯着看了半小时，因为它思考的连贯性太像人了，你会看到它"翻旧账"、"走神"、"突然想到什么然后去验证"，那种感觉很难用文字形容。

Dashboard 的另一个实用价值是可观测性。agent 干了任何事都有迹可循，出问题了能顺着时间线回放。对于想拿 Headlong 做实