<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>钰熙的博客</title>
    <link>https://yuxi2738.de5.net</link>
    <description>记录思考，分享所学，留住当下。</description>
    <language>zh-CN</language>
    <atom:link href="https://yuxi2738.de5.net/feed.xml" rel="self" type="application/rss+xml"/>
    <item>
      <title>DeepSeek Harness：为什么「持续学习」要先从一块可拆装的身体开始</title>
      <link>https://yuxi2738.de5.net/deepseek-harness</link>
      <guid isPermaLink="true">https://yuxi2738.de5.net/deepseek-harness</guid>
      <description>从梁文锋闭门会的一句话，到 deepseek-harness 开源仓库里的 5 个小工具：想让 AI 学会自我进化，第一步不是教它「怎么进化」，而是先给它一个改不坏、拆得开、试得了错的工作环境。</description>
      <content:encoded><![CDATA[<style>
#post-content-deepseek-harness {
  --accent: var(--editor-accent);
  --accent-deep: var(--editor-link);
  --accent-soft: color-mix(in srgb, var(--editor-accent) 12%, transparent);
  --fg-soft: var(--article-body);
  --fg-faint: var(--stone-gray);
  --line: var(--editor-line);
  --line-strong: var(--border-warm);
  --code-bg: var(--editor-code-bg);
  --bg-soft: var(--editor-panel);
  --danger-line: #d9a08c;
}
#post-content-deepseek-harness .part-divider {
  margin: 3em 0 1em; padding: 1.2em 1.4em;
  background: var(--editor-panel);
  border-top: 1px solid var(--editor-line);
  border-bottom: 1px solid var(--editor-line);
  display: flex; align-items: baseline; gap: 14px;
}
#post-content-deepseek-harness .part-divider .pd-label {
  font-family: Georgia, 'Noto Serif SC', serif;
  font-size: 1.25rem; font-weight: 700; white-space: nowrap;
}
#post-content-deepseek-harness .part-divider .pd-desc { font-size: .85rem; color: var(--fg-soft); }
#post-content-deepseek-harness .part-divider .pd-desc b { color: var(--editor-accent); }
#post-content-deepseek-harness .thesis {
  margin: .8em 0 1.4em; padding: .8em 1.1em;
  border-left: 3px solid var(--editor-accent);
  background: color-mix(in srgb, var(--editor-accent) 10%, transparent);
  border-radius: 0 6px 6px 0;
  font-size: .93rem;
}
#post-content-deepseek-harness .thesis b {
  display: block; font-size: .72rem; letter-spacing: .12em;
  text-transform: uppercase; margin-bottom: 3px; opacity: .8;
}
#post-content-deepseek-harness .callout {
  margin: 1.4em 0; padding: 1em 1.2em; border-radius: 6px; border: 1px solid; font-size: .93rem;
}
#post-content-deepseek-harness .callout .ct-label {
  font-weight: 700; font-size: .78rem; letter-spacing: .08em;
  text-transform: uppercase; margin-bottom: 4px; display: block;
}
#post-content-deepseek-harness .callout.info { background: var(--editor-panel); border-color: var(--editor-accent); }
#post-content-deepseek-harness .callout.info .ct-label { color: var(--editor-accent); }
#post-content-deepseek-harness .callout.warn { background: color-mix(in srgb, #d9b86a 14%, transparent); border-color: #d9b86a; }
#post-content-deepseek-harness .callout.warn .ct-label { color: var(--fg-soft); }
#post-content-deepseek-harness .callout.ok { background: color-mix(in srgb, #9db88f 14%, transparent); border-color: #9db88f; }
#post-content-deepseek-harness .callout.ok .ct-label { color: var(--fg-soft); }
#post-content-deepseek-harness .callout.danger { background: color-mix(in srgb, #d9a08c 14%, transparent); border-color: #d9a08c; }
#post-content-deepseek-harness .callout.danger .ct-label { color: var(--fg-soft); }
#post-content-deepseek-harness .callout p { margin: 3px 0; }
#post-content-deepseek-harness .tldr {
  margin: 2em 0 .5em; border: 1px solid var(--editor-line); border-radius: 6px;
  background: var(--editor-panel); padding: 1.5em 1.6em;
}
#post-content-deepseek-harness .tldr .tldr-label {
  font-size: .75rem; letter-spacing: .16em; text-transform: uppercase;
  color: var(--editor-accent); font-weight: 700; margin-bottom: .8em;
}
#post-content-deepseek-harness .tldr ol { margin: 0 0 0 1.3em; }
#post-content-deepseek-harness .gaps { display: grid; gap: 14px; margin: 1.4em 0; }
#post-content-deepseek-harness .gap {
  border: 1px solid var(--editor-line); border-left: 3px solid var(--editor-accent);
  border-radius: 6px; padding: 1.1em 1.2em;
}
#post-content-deepseek-harness .gap h4 {
  font-family: Georgia, 'Noto Serif SC', serif;
  font-size: 1.02rem; margin-bottom: 4px;
  display: flex; align-items: center; gap: 8px; color: var(--article-heading);
}
#post-content-deepseek-harness .gap h4 .tag { font-size: .68rem; color: var(--stone-gray); font-weight: 400; }
#post-content-deepseek-harness .gap p { margin: 4px 0; font-size: .9rem; color: var(--fg-soft); }
#post-content-deepseek-harness .steps { counter-reset: step; margin: 1.2em 0; }
#post-content-deepseek-harness .step {
  counter-increment: step; display: grid; grid-template-columns: 36px 1fr; gap: 14px; margin: .9em 0;
}
#post-content-deepseek-harness .step::before {
  content: counter(step, decimal-leading-zero);
  font-size: .75rem; font-weight: 700; color: var(--editor-accent);
  background: color-mix(in srgb, var(--editor-accent) 12%, transparent);
  border: 1px solid var(--editor-accent);
  width: 36px; height: 36px; border-radius: 50%;
  display: flex; align-items: center; justify-content: center; margin-top: 1px;
}
#post-content-deepseek-harness .step b.t { display: block; margin-bottom: 2px; }
#post-content-deepseek-harness .diagram { margin: 1.6em 0; }
#post-content-deepseek-harness .diagram figcaption {
  text-align: center; font-size: .78rem; color: var(--stone-gray); margin-top: 8px;
}
#post-content-deepseek-harness .diagram svg { width: 100%; height: auto; }
#post-content-deepseek-harness svg .box { fill: var(--editor-panel); stroke: var(--border-warm); stroke-width: 1.2; }
#post-content-deepseek-harness svg .box-accent { fill: color-mix(in srgb, var(--editor-accent) 12%, transparent); stroke: var(--editor-accent); stroke-width: 1.5; }
#post-content-deepseek-harness svg .box-dim { fill: transparent; stroke: var(--border-warm); stroke-dasharray: 5 4; stroke-width: 1.2; }
#post-content-deepseek-harness svg .box-label { fill: var(--article-heading); font-size: 12.5px; font-weight: 600; }
#post-content-deepseek-harness svg .box-sub { fill: var(--fg-soft); font-size: 11px; }
#post-content-deepseek-harness svg .arrow { stroke: var(--fg-soft); stroke-width: 1.5; fill: none; }
#post-content-deepseek-harness svg .arrow-accent { stroke: var(--editor-accent); stroke-width: 1.8; fill: none; }
#post-content-deepseek-harness svg text { font-family: -apple-system, 'PingFang SC', 'Noto Sans SC', sans-serif; }
#post-content-deepseek-harness pre { font-size: .85em; }
#post-content-deepseek-harness .tok-c { color: var(--stone-gray); font-style: italic; }
</style>

<section class="tldr">
      <div class="tldr-label">TL;DR — 三分钟读完</div>
      <ol>
        <li><b>梁文锋在闭门会上说：Agent 之后，下一个要解决的问题是持续学习。</b> 这不是让模型在线更新参数，而是一个包含「记住过去、改变策略、验证效果」的系统工程问题。</li>
        <li><b>DeepSeek 开源了 deepseek-harness</b>：一个让 AI 的工作环境「所有零件都能拆」的运行时。文档原话——产品的每一部分都是插件，包括 agent loop 本身。</li>
        <li><b>它给了 AI 5 个小工具</b>（照镜子、画图纸、装上去、拔下来、忘掉），让 AI 能观察自己的运行时、现场造一个新零件、装上试错、不行就拆。这是「能自己改自己」，离「自己进化」还差三步。</li>
        <li><b>真正值得关注的不是功能，而是思路</b>：从「人手工搭好一切」走向「让 AI 自己也能调整工作方式」——和 DeepSeek-R1 用强化学习让推理能力自己长出来的路线，是一脉相承的。</li>
      </ol>
    </section>

    <!-- ═══ 第一部分：为什么要这么做 ═══ -->
    <div class="part-divider">
      <span class="pd-label">第一部分</span>
      <span class="pd-desc"><b>为什么要这么做</b>——问题是从哪儿来的：AI 的能力，为什么这么依赖它的工作环境？</span>
    </div>

    <section id="s1">
      <h2><span class="secnum">01</span>梁文锋的一句话</h2>
      <div class="thesis"><b>一句话论点</b>「持续学习」被定义成一个问题，而不是一项技术——它需要很多领域一起解决。</div>
      <p>前段时间有一份梁文锋闭门会的公开整理流传出来，里面有一句话值得多看两眼：</p>
      <blockquote>
        <p>Agent 之后，下一个要解决的问题是持续学习。</p>
        <span class="src">梁文锋，闭门交流，2026 年 7 月</span>
      </blockquote>
      <p>他还给 AI 这几年画了一条很直白的路线：<strong>前一阶段是 CoT，今年看到的是 Agent，而 Agent 再往后，真正卡住的地方是「怎么持续学习」。</strong>他还提到一个 DeepSeek 内部很看重的想法：下一代模型最好先能帮 DeepSeek 自己提高研发效率——能参与开发自己的下一代模型。</p>
      <div class="callout warn">
        <span class="ct-label">先说明来源</span>
        <p>以上是《每日经济新闻》2026 年 7 月对一场闭门交流的整理，<strong>并不是 DeepSeek 官网发布的正式路线图</strong>。本文不把其中每句话理解成「DeepSeek 已经决定这么干」，只把它当作理解 DeepSeek 最近开源动作的一把钥匙。</p>
      </div>
      <p>有意思的是，如果把「持续学习」当成一个<strong>问题</strong>而不是一项<strong>技术</strong>，它马上会展开成一系列小问题：记住过去发生过什么、判断哪些经验还有用、发现自己反复在犯什么错、改变工作策略、获得新工具、淘汰坏工具、验证改动是不是真的更好——其中一部分属于模型训练，一部分属于记忆，一部分属于工作环境，一部分甚至只是软件工程问题。梁文锋自己也在那次交流中说：<strong>「持续学习可能不是某一项单独技术，而是一个问题，可能需要很多东西一起解决。」</strong></p>
      <p>而 deepseek-harness 这个项目，恰好把其中一个长期被忽略的小问题，摆到了台面上。</p>
    </section>

    <section id="s2">
      <h2><span class="secnum">02</span>一个看似普通的开源项目</h2>
      <div class="thesis"><b>一句话论点</b>这个项目第一眼很平淡，直到文档第一段写了一句「产品的每一部分都是插件」。</div>
      <p>如果只看名字——<code>deepseek-ai/deepseek-harness</code>——第一反应很平淡。这类「AI 的外壳」每隔一段时间就冒出一个新框架：支持 Tool、支持 Skill、支持 MCP、支持记忆、支持沙箱……如果只是再做一套外壳，实在很难让人兴奋。</p>
      <p>真正让这个项目变得不一样的，是文档第一段那句话：</p>
      <blockquote>
        <p>产品的每一部分都是插件，包括模型适配器、工具注册表、会话日志，以及 agent loop 本身。</p>
        <span class="src">deepseek-harness 官方文档</span>
      </blockquote>
      <p>翻译成大白话就是：<strong>这个 AI 的「身体」没有任何一块是焊死的，连大脑怎么转圈（agent loop）都能换。</strong></p>
      <p>再往下翻，还有一套直接给 AI 用的工具：</p>
      <pre><code>cordis_inspect   <span class="tok-c"># 照镜子：看看自己身体里现在装着什么</span>
cordis_define    <span class="tok-c"># 画图纸：写一个新零件的设计图</span>
cordis_run       <span class="tok-c"># 装上去：把新零件真正装进身体</span>
cordis_stop      <span class="tok-c"># 拔下来：停掉一个零件</span>
cordis_undefine  <span class="tok-c"># 忘掉：连设计图一起删掉</span></code></pre>
      <p>问题从这里开始变得有意思：<strong>DeepSeek 到底为什么要让 AI 盯着自己的运行时，现场画个图纸、造个零件、再装到自己身上？</strong>如果只是想给 AI「加功能」，Pi、VS Code 这些成熟的插件系统不是早就解决了吗？</p>
    </section>

    <section id="s3">
      <h2><span class="secnum">03</span>同样的模型，换套环境就差很多</h2>
      <div class="thesis"><b>一句话论点</b>AI 的真实表现 = 模型本身 × 工作环境。同一个大脑，换一套工作台，产出完全不同。</div>
      <p>先从一个很实际的现象说起：<strong>同一个模型，放进不同的 Coding Agent 里，表现能差很多。为什么？</strong></p>
      <p>因为模型真正干活的时候，从来不是光着身子的。一个 Coding Agent 外面通常还有一整套东西：</p>
      <ul>
        <li>系统提示词（System Prompt）、上下文管理、会话记录、记忆</li>
        <li>读文件、跑命令、用 Git、开浏览器、搜索、代码索引</li>
        <li>子代理、沙箱、权限控制、循环逻辑、界面</li>
      </ul>
      <p>打个比方：<strong>模型是一个程序员的大脑，Harness 是这个程序员手里的电脑、IDE、终端、浏览器、调试器、项目文档和工作习惯。</strong>你让一个很强的程序员只拿记事本写代码，和让他用全套开发工具，最后做出来的东西当然不一样。</p>
      <figure class="diagram">
        <svg viewBox="0 0 700 150" width="100%" role="img" aria-label="AI 真实表现 = 模型能力 × 工作环境">
          <defs>
            <marker id="arrowhead" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 Z" fill="var(--fg-soft)"/></marker>
            <marker id="arrowheadAccent" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 Z" fill="var(--accent)"/></marker>
          </defs>
          <rect x="40" y="35" width="150" height="80" rx="10" class="box-accent"/>
          <text x="115" y="70" text-anchor="middle" class="box-label">模型本身</text>
          <text x="115" y="92" text-anchor="middle" class="box-sub">大脑 · 参数 · 推理</text>
          <text x="222" y="80" text-anchor="middle" font-size="22" fill="var(--accent)" font-weight="700">×</text>
          <rect x="245" y="35" width="150" height="80" rx="10" class="box-accent"/>
          <text x="320" y="70" text-anchor="middle" class="box-label">工作环境</text>
          <text x="320" y="92" text-anchor="middle" class="box-sub">工具 · 流程 · 习惯</text>
          <line x1="430" y1="75" x2="490" y2="75" class="arrow-accent"/>
          <rect x="500" y="30" width="160" height="90" rx="10" class="box"/>
          <text x="580" y="65" text-anchor="middle" class="box-label" fill="var(--accent)">真实表现</text>
          <text x="580" y="88" text-anchor="middle" class="box-sub">不是考试分数</text>
          <text x="580" y="106" text-anchor="middle" class="box-sub">是两者相乘的结果</text>
        </svg>
        <figcaption>图 1 · AI 不是裸奔的：工作环境不是包装，是放大器</figcaption>
      </figure>
      <p>这件事本身不算新鲜。真正新鲜的问题在后面：</p>
      <div class="callout info">
        <span class="ct-label">本文要聊的核心问题</span>
        <p><strong>既然工作环境对 AI 的影响这么大，为什么工作环境永远只能由人来搭？</strong></p>
      </div>
    </section>

    <section id="s4">
      <h2><span class="secnum">04</span>现在的 AI，工作台都是人搭的</h2>
      <div class="thesis"><b>一句话论点</b>人用半年会自己改进工作方式；AI 却只能被动等人帮它改——这中间的落差，就是「持续学习」想填的坑。</div>
      <p>现在我们用 Pi、Claude Code、Codex，本质上还是人先帮 AI 把「工作台」搭好：装哪些插件、给哪些工具、提示词怎么写、什么时候派子代理、记忆怎么组织、任务怎么拆。<strong>AI 只是在这套环境里干活，环境本身它碰不了。</strong></p>
      <p>但人类程序员不是这样的。一个程序员工作半年以后会自己变：发现「我每次修完 Bug 都忘记跑测试」，于是养成「改完必须验证」的习惯；发现「我天天手工查数据库结构，太浪费时间」，于是去找个插件装上。这些变化没有重新训练他的大脑，但他的实际工作能力确实变强了——变的只是他的<strong>工具、流程、习惯、环境</strong>。</p>
      <p>换到 AI 身上，这些恰好就是它的工作环境（Harness）。所以「持续学习」如果要进入 AI，至少存在另一条很自然的路线：</p>
      <pre><code>模型内部学习   +   工作环境的外部学习
     │                    │
   改「大脑」           改「工作方式」</code></pre>
      <p><strong>DeepSeek Harness 真正值得看的地方，就在这里——它正在给第二条路打地基。</strong></p>
    </section>

    <!-- ═══ 第二部分：它存在的价值 ═══ -->
    <div class="part-divider">
      <span class="pd-label">第二部分</span>
      <span class="pd-desc"><b>它存在的价值</b>——这东西解决了什么真问题：普通插件为什么不够？「可拆装」为什么是前提？</span>
    </div>

    <section id="s5">
      <h2><span class="secnum">05</span>普通插件为什么不够用</h2>
      <div class="thesis"><b>一句话论点</b>加插件是「给稳定的身体加器官」；DeepSeek Harness 要解决的是「身体本身也能换」——这是两个层面。</div>
      <p>那问题来了：<strong>为什么非得把工作环境做成能现场改的？普通插件不行吗？</strong>这也是最容易被问住的点。</p>
      <p>以 Pi 为例，它的设计其实很好理解：<strong>Pi + 插件</strong>。要 GitHub 就装 GitHub 插件，要浏览器就装浏览器插件，要特殊流程就写一个插件，干活的时候 AI 自己决定用哪个工具。对绝大多数场景来说，这套设计完全够用——如果 DeepSeek Harness 只是想解决「AI 怎么获得更多工具」，重新造这么一套复杂的东西，没必要。</p>
      <p>所以必须先分清两件事：</p>
      <div class="tablewrap">
        <table>
          <thead>
            <tr><th>对比</th><th>Pi / 传统插件系统</th><th>DeepSeek Harness</th></tr>
          </thead>
          <tbody>
            <tr>
              <td><b>问的问题</b></td>
              <td>怎么让一个<strong>稳定的身体</strong>很容易增加新能力？</td>
              <td>如果连<strong>身体本身</strong>以后都要换，怎么办？</td>
            </tr>
            <tr>
              <td><b>能动的范围</b></td>
              <td>前半段用插件 A，后半段用插件 B</td>
              <td>记忆换掉、循环逻辑换成另一种、文件系统换成远程沙箱、工具清单直接换</td>
            </tr>
            <tr>
              <td><b>边界在哪</b></td>
              <td>身体神圣不可碰，插件在边缘长</td>
              <td>「不存在需要打补丁的特权内核」——<em>连核心都是可拆的</em></td>
            </tr>
            <tr>
              <td><b>最极端的场景</b></td>
              <td>—（不需要支持）</td>
              <td>AI 自己刚写了一个运行时零件，<strong>当场就装进去试</strong></td>
            </tr>
          </tbody>
        </table>
      </div>
      <p>这里的「插件」虽然同名，聊的已经不是一回事了。<strong>DeepSeek Harness 是在为一个前提做工程准备：你想让 AI 改自己，首先得让「自己」拆得开。</strong></p>
    </section>

    <section id="s6">
      <h2><span class="secnum">06</span>核心价值：一个改不死的身体</h2>
      <div class="thesis"><b>一句话论点</b>让 AI 敢拆自己，靠的不是「自觉」，而是两条硬规则：拆得干净（可逆）、知道谁离不开谁（依赖感知）。</div>
      <p>让 AI 能拆自己，最难的不是「拆」这个动作，而是<strong>拆完别出事</strong>。如果 AI 把记忆模块换掉了，正在用的规划模块还握着旧记忆继续跑，系统就会进入一种很危险的「半死不活」状态。谁来保证这种事不发生？</p>
      <p>Cordis（这套技术的地基）用两条规则回答：</p>

      <h3>规则一：拆得干净——谁搬进来的，谁走的时候搬走</h3>
      <blockquote>
        <p>谁注册的资源，谁的生命周期结束时，资源一起回收。</p>
        <span class="src">Cordis 的核心规则</span>
      </blockquote>
      <p>白话版：<strong>谁把桌子搬进来的，走的时候顺手搬走，别留在走廊里挡路。</strong></p>
      <p>为什么这条规则这么重要？想象一个插件启动时做了一堆事：注册一个命令、监听三个事件、启动一个计时器、挂一个中间件、提供一个服务。如果卸载的时候作者少清理一个监听器，会发生什么？</p>
      <div class="tablewrap">
        <table>
          <thead><tr><th>场景</th><th>结果</th></tr></thead>
          <tbody>
            <tr><td>装一次、卸一次</td><td>看不出任何问题</td></tr>
            <tr><td>反复装卸几十次</td><td>运行时里留下一堆<strong>看不见的「幽灵」</strong>——行为越来越诡异，而且极难排查</td></tr>
          </tbody>
        </table>
      </div>
      <p>长期运行的软件最怕这种东西。可逆，就是 Cordis 最早要解决的现实问题。</p>

      <h3>规则二：知道谁离不开谁——依赖感知</h3>
      <p>光能「拆干净」还不够，零件之间还会互相依赖：</p>
      <pre><code>数据库
   ↑
用户系统
   ↑
积分插件</code></pre>
      <p>数据库被卸了，用户系统怎么办？Cordis 的做法不是假设「依赖在启动时存在，以后永远存在」，而是让每个零件声明「我需要数据库」，然后按需开工：</p>
      <figure class="diagram">
        <svg viewBox="0 0 700 150" width="100%" role="img" aria-label="依赖感知：零件随依赖的出现和消失而开工和停工">
          <rect x="30" y="45" width="180" height="60" rx="10" class="box"/>
          <text x="120" y="70" text-anchor="middle" class="box-label">数据库不存在</text>
          <text x="120" y="90" text-anchor="middle" class="box-sub">依赖它的零件先等着</text>
          <line x1="210" y1="65" x2="268" y2="65" class="arrow"/>
          <text x="239" y="52" text-anchor="middle" font-size="10.5" fill="var(--fg-soft)">出现</text>
          <rect x="278" y="45" width="170" height="60" rx="10" class="box-accent"/>
          <text x="363" y="70" text-anchor="middle" class="box-label">开工</text>
          <text x="363" y="90" text-anchor="middle" class="box-sub">依赖的部分开始工作</text>
          <line x1="448" y1="65" x2="506" y2="65" class="arrow"/>
          <text x="477" y="52" text-anchor="middle" font-size="10.5" fill="var(--fg-soft)">消失</text>
          <rect x="516" y="45" width="170" height="60" rx="10" class="box"/>
          <text x="601" y="70" text-anchor="middle" class="box-label">停工等待</text>
          <text x="601" y="90" text-anchor="middle" class="box-sub">等新的数据库出现再继续</text>
          <line x1="686" y1="105" x2="120" y2="115" class="arrow" transform="translate(0,10)"/>
        </svg>
        <figcaption>图 2 · 依赖感知：零件随依赖的出现/消失自动开工/停工</figcaption>
      </figure>
      <p>所以 Cordis 说到底在管两件事：<strong>这个零件做了什么？这个零件需要什么？</strong></p>
      <div class="callout ok">
        <span class="ct-label">为什么这是「价值」</span>
        <p>这两条规则凑在一起，才让「AI 自己改自己」从一句吓人的话变成一件<strong>技术上敢做的事</strong>——因为系统保证：拆得掉、坏不了、救得回。</p>
      </div>
    </section>

    <section id="s7">
      <h2><span class="secnum">07</span>这套技术是从哪来的：一个聊天机器人的故事</h2>
      <div class="thesis"><b>一句话论点</b>Cordis 不是为 AI 设计的——它是聊天机器人框架 Koishi 被「长期运行、反复更新、海量插件」逼出来的工程答案。</div>
      <p>DeepSeek Harness 文档里写着 <code>Powered by Cordis</code>。第一次看到很容易以为这是 DeepSeek 为 AI 新做的一套系统，其实不是——<strong>Cordis 来自 Koishi，一个聊天机器人框架</strong>，2020 年发布第一个正式版本。</p>
      <p>聊天机器人和插件系统的关系，比 Coding Agent 更「生死攸关」：一个 Bot 同时服务很多群、很多用户，如果更新一个插件就要重启整个机器人，体验极差。于是很自然地想：<strong>只拔掉插件 A，换成 A2，其他东西继续跑。</strong></p>
      <p>说起来简单，真正难的是「拔」。Koishi 官方设计文章把这个问题叫得很直接：</p>
      <blockquote>
        <p>可逆的插件系统：不管插件之前加载、卸载过多少次，系统现在的行为应该只由「现在有哪些插件」决定，而不是被历史残留影响。</p>
        <span class="src">Koishi 官方设计文章</span>
      </blockquote>
      <p>Koishi 官方自己也说得很坦白：<strong>这些理论不是先设计好再塞进项目里的，而是多年工程实践先长出来，后来才总结成理论。</strong>这说明 Cordis 不是为了「架构看起来高级」而存在的——它是被真实问题逼出来的。</p>
      <p>那它为什么会突然和「AI 自我进化」扯上关系？因为 AI 把原来的问题放大了：Koishi 的世界是「人写插件 → 系统帮你安全加载」；而自我进化的 AI 想象中是「AI 自己写插件 → 自己加载 → 自己替换 → 自己发现不对 → 自己撤销」。这时你不能再指望「插件作者足够自觉」，<strong>因为插件作者可能就是 AI 自己</strong>——它今天注册了一个监听器，五分钟后把自己的实现换了，它还记得旧监听器在哪吗？它换了记忆模块，规划模块还在用旧记忆吗？它改坏了一个关键零件，谁负责把它救回来？</p>
      <p>Cordis 这套沉淀多年的「拆得干净 + 知道依赖」的能力，在这里突然变得非常合适——<strong>这大概就是 DeepSeek 选它的原因。</strong></p>
    </section>

    <section id="s8">
      <h2><span class="secnum">08</span>为什么这件事值得关注</h2>
      <div class="thesis"><b>一句话论点</b>现在大家已经对「AI 新功能」疲劳了；真正值得问的是：这些功能本身，以后由谁决定？</div>
      <p>现在大家真的已经有点「AI 新功能疲劳」了。再告诉我们：支持 MCP、支持 Skill、支持子代理、支持记忆、支持浏览器——很难兴奋。这些都是「AI 有什么功能」。</p>
      <p>DeepSeek Harness 更有意思的问题是：<strong>这些功能本身，以后是谁决定的？</strong></p>
      <div class="tablewrap">
        <table>
          <thead><tr><th>阶段</th><th>谁在决定工作环境</th><th>场景</th></tr></thead>
          <tbody>
            <tr><td><b>今天</b></td><td>人</td><td>我们帮 AI 装插件、写 Skill、调提示词、配流程</td></tr>
            <tr><td><b>未来？</b></td><td>人 + AI 自己</td><td>AI 干活时发现缺能力 → 找现成插件，没有就自己造一个；某种工作方式反复失败 → 提出新方案 → 先装上试 → 不行就拆 → 好用很多次再留下</td></tr>
          </tbody>
        </table>
      </div>
      <p>这时候「插件」就不再只是生态里的小功能，它变成了<strong>AI 调整自己工作方式的最小单位</strong>。这也是「持续学习」真正落地时需要的形状：不是改参数，而是改工具、改流程、改习惯——和人类程序员半年后的自我进化，是同一件事。</p>
    </section>

    <!-- ═══ 第三部分：具体怎么做 ═══ -->
    <div class="part-divider">
      <span class="pd-label">第三部分</span>
      <span class="pd-desc"><b>具体怎么做</b>——DeepSeek Harness 拆开来长什么样：先让身体可拆，再给 AI 一面镜子和一套工具，最后还差什么。</span>
    </div>

    <section id="s9">
      <h2><span class="secnum">09</span>第一步：让「自己」可以拆</h2>
      <div class="thesis"><b>一句话论点</b>想改自己，先得让自己拆得开——所以它没有「神圣不可碰的核心」，一切皆插件。</div>
      <p>官方文档写得非常明确：产品的每一部分都是插件，包括模型适配器、工具注册表、会话日志，以及 agent loop 本身。文档甚至用了一个很直接的说法：<strong>「不存在需要打补丁的特权内核」</strong>——没有哪一块是焊死的。</p>
      <p>架构大致长这样：</p>
      <figure class="diagram">
        <svg viewBox="0 0 700 220" width="100%" role="img" aria-label="DeepSeek Harness 架构图">
          <rect x="255" y="18" width="190" height="56" rx="10" class="box-accent"/>
          <text x="350" y="42" text-anchor="middle" class="box-label">Cordis 底座</text>
          <text x="350" y="62" text-anchor="middle" class="box-sub">管所有零件的装卸和依赖</text>
          <line x1="350" y1="74" x2="350" y2="102" class="arrow"/>
          <rect x="20" y="108" width="150" height="64" rx="10" class="box"/>
          <text x="95" y="134" text-anchor="middle" class="box-label">循环逻辑</text>
          <text x="95" y="154" text-anchor="middle" class="box-sub">可换成另一种循环</text>
          <rect x="275" y="108" width="150" height="64" rx="10" class="box"/>
          <text x="350" y="134" text-anchor="middle" class="box-label">工具清单</text>
          <text x="350" y="154" text-anchor="middle" class="box-sub">工具注册表可换</text>
          <rect x="530" y="108" width="150" height="64" rx="10" class="box"/>
          <text x="605" y="134" text-anchor="middle" class="box-label">会话记录</text>
          <text x="605" y="154" text-anchor="middle" class="box-sub">日志本身也是插件</text>
          <line x1="95" y1="172" x2="95" y2="196" class="arrow"/>
          <line x1="350" y1="172" x2="350" y2="196" class="arrow"/>
          <line x1="605" y1="172" x2="605" y2="196" class="arrow"/>
          <text x="95" y="212" text-anchor="middle" font-size="11" fill="var(--fg-soft)">大模型</text>
          <text x="350" y="212" text-anchor="middle" font-size="11" fill="var(--fg-soft)">沙箱</text>
          <text x="605" y="212" text-anchor="middle" font-size="11" fill="var(--fg-soft)">提示词</text>
        </svg>
        <figcaption>图 3 · 架构：Cordis 底座之上，一切皆插件</figcaption>
      </figure>
      <p>这看起来只是工程上的「洁癖」，其实它是自我进化的<strong>第一个前提</strong>：你想让 AI 改自己，首先得让「自己」是可以拆的。零件都焊死了，谈什么改装？</p>
    </section>

    <section id="s10">
      <h2><span class="secnum">10</span>第二步：一面镜子，一套工具</h2>
      <div class="thesis"><b>一句话论点</b>目前做到的是：照镜子 → 画图纸 → 装上 → 拔下 → 忘掉。其中「画图纸不执行、装上去才有动作」是最聪明的小设计。</div>

      <h3>10.1 一面镜子：照见自己</h3>
      <p>仓库里有个包叫 <code>tool-cordis</code>，README 第一行就叫「自引用 Cordis 工具集」。它给 AI 的第一个工具 <code>cordis_inspect</code>，作用是<strong>让 AI 看到自己身体里现在装着什么</strong>：有哪些服务、哪些插件还活着、注册了哪些工具、有哪些动态包、接口是什么、有哪些事件。</p>
      <p>这个变化很有意思：以前 Coding Agent 能看项目代码、文件系统、终端、浏览器、Git——都是<strong>外界</strong>；现在它还能看<strong>「我自己现在是什么结构」</strong>。把 AI 比作人，这差不多是从「只会看外面」进化到「至少知道自己身体里装了什么」。当然，看到自己不等于会进化——但没有这一步，后面都没法谈。</p>

      <h3>10.2 一套工具：画图纸 → 装上去</h3>
      <p>更关键的是它已经能现场给自己「装零件」。<code>cordis_define</code> 允许 AI 提交一个新零件的设计图，里面可以有名字、用途、代码。这里有一个很聪明的小设计：</p>
      <div class="callout info">
        <span class="ct-label">最聪明的小设计</span>
        <p><strong>画图纸（define）不执行。</strong>它只是先登记、检查语法。真正有动作的是下一步：装上去（run）。</p>
      </div>
      <p>为什么要分开？因为「设计」是无害的，可以随便试；「安装」才真正改变身体。分开以后，AI 可以先大胆画图纸，确认没问题再装——<strong>想清楚再动手，动手就要负责。</strong></p>
      <p>于是理论上可以发生这样的事：</p>
      <div class="steps">
        <div class="step"><div><b class="t">AI 正在做任务</b>——做到一半</div></div>
        <div class="step"><div><b class="t">发现缺一个很特殊的小工具</b>——没有现成的</div></div>
        <div class="step"><div><b class="t">自己写一个</b>——提交 cordis_define</div></div>
        <div class="step"><div><b class="t">cordis_run</b>——新工具进入运行时</div></div>
        <div class="step"><div><b class="t">下一轮，它真的能调用这个工具</b></div></div>
      </div>
      <p>这就不是「让 AI 帮忙写个插件文件」了，而是：<strong>AI 在当前任务还没结束时，直接改变了自己的运行时能力。</strong></p>

      <h3>10.3 拔下来、忘掉：改坏了能救回来</h3>
      <p>改坏了怎么办？<code>cordis_stop</code> 会把运行中的零件停掉，系统会清理干净它注册过的一切；<code>cordis_undefine</code> 则更进一步，连设计图也删掉。整个过程像一张完整的「实验循环」：</p>
      <figure class="diagram">
        <svg viewBox="0 0 700 120" width="100%" role="img" aria-label="运行时实验台循环：画图纸、装上去、拔下来、忘掉">
          <rect x="25" y="30" width="130" height="60" rx="10" class="box"/>
          <text x="90" y="55" text-anchor="middle" class="box-label">画图纸</text>
          <text x="90" y="75" text-anchor="middle" class="box-sub">define（无动作）</text>
          <line x1="155" y1="60" x2="208" y2="60" class="arrow-accent"/>
          <rect x="218" y="30" width="130" height="60" rx="10" class="box-accent"/>
          <text x="283" y="55" text-anchor="middle" class="box-label">装上去</text>
          <text x="283" y="75" text-anchor="middle" class="box-sub">run（真正生效）</text>
          <line x1="348" y1="60" x2="401" y2="60" class="arrow"/>
          <rect x="411" y="30" width="130" height="60" rx="10" class="box"/>
          <text x="476" y="55" text-anchor="middle" class="box-label">拔下来</text>
          <text x="476" y="75" text-anchor="middle" class="box-sub">stop（清理干净）</text>
          <line x1="541" y1="60" x2="594" y2="60" class="arrow"/>
          <rect x="604" y="30" width="80" height="60" rx="10" class="box"/>
          <text x="644" y="55" text-anchor="middle" class="box-label">忘掉</text>
          <text x="644" y="75" text-anchor="middle" class="box-sub">undefine</text>
        </svg>
        <figcaption>图 4 · 一个「运行时实验台」：AI 可以在自己身上做短期实验</figcaption>
      </figure>
      <p>它已经很像一个实验台——AI 可以在自己身上做短期实验，而不是每改一点东西就：杀掉进程、重新启动、祈祷上下文还在。</p>
    </section>

    <section id="s11">
      <h2><span class="secnum">11</span>目前还差的三步</h2>
      <div class="thesis"><b>一句话论点</b>现在是「能自己改自己」，不是「自己进化」。「会改」离「会进化」还差三个闭环：为什么改、怎么判好坏、怎么留下来。</div>
      <p>这算自我进化了吗？还不能。更准确的说法是<strong>「能自己改自己的工作环境」</strong>——能改，不等于会进化。完整的自我进化至少应该有这样一个循环：</p>
      <figure class="diagram">
        <svg viewBox="0 0 700 190" width="100%" role="img" aria-label="自我进化完整闭环 vs 当前实现">
          <text x="30" y="22" font-size="12.5" font-weight="700" fill="var(--fg-soft)">理想闭环（虚线：尚未完成）</text>
          <rect x="30" y="34" width="620" height="120" rx="10" class="box-dim"/>
          <rect x="52" y="52" width="130" height="52" rx="8" class="box"/>
          <text x="117" y="74" text-anchor="middle" class="box-label">做很多真实任务</text>
          <text x="117" y="92" text-anchor="middle" class="box-sub">记录失败模式</text>
          <line x1="182" y1="78" x2="222" y2="78" class="arrow"/>
          <rect x="232" y="52" width="130" height="52" rx="8" class="box"/>
          <text x="297" y="74" text-anchor="middle" class="box-label">找出失败原因</text>
          <text x="297" y="92" text-anchor="middle" class="box-sub">是能力差还是方法差？</text>
          <line x1="362" y1="78" x2="402" y2="78" class="arrow"/>
          <rect x="412" y="52" width="130" height="52" rx="8" class="box"/>
          <text x="477" y="74" text-anchor="middle" class="box-label">提出改进方案</text>
          <text x="477" y="92" text-anchor="middle" class="box-sub">画图纸 + 装上去</text>
          <line x1="542" y1="78" x2="582" y2="78" class="arrow"/>
          <rect x="592" y="52" width="48" height="52" rx="8" class="box-accent"/>
          <text x="616" y="78" text-anchor="middle" class="box-label">试</text>
          <line x1="616" y1="104" x2="616" y2="128" class="arrow"/>
          <rect x="430" y="122" width="186" height="44" rx="8" class="box"/>
          <text x="523" y="141" text-anchor="middle" class="box-label">考试对比</text>
          <text x="523" y="158" text-anchor="middle" class="box-sub">成功率·成本·速度·安全</text>
          <line x1="430" y1="144" x2="360" y2="144" class="arrow"/>
          <text x="395" y="138" text-anchor="middle" font-size="11" fill="var(--accent)">更好→保留</text>
          <line x1="616" y1="90" x2="640" y2="90" class="arrow" stroke="var(--danger-line)"/>
          <text x="700" y="84" text-anchor="middle" font-size="11" fill="var(--danger-line)">更差→回滚</text>
        </svg>
        <figcaption>图 5 · 完整的自我进化闭环（深色块 = DeepSeek Harness 已完成的中间一截）</figcaption>
      </figure>
      <p>DeepSeek Harness 目前公开的代码，已经明显完成了中间这一截——<strong>照镜子 → 临时改 → 运行 → 撤销</strong>——但前后两头还没闭环：</p>

      <div class="gaps">
        <div class="gap">
          <h4>缺口一 · 为什么要改？ <span class="tag">缺：失败归因</span></h4>
          <p>AI 能画图纸装零件，并不代表它知道「我到底该改什么」。假设一个 AI 做了 1000 个任务，在大项目的探索上成功率特别差。一个真正会进化的系统应该能进一步发现：不是它代码能力差，而是「我经常找不到关键文件、搜索次数太多、上下文塞得很乱」——然后才有理由说「也许该改改项目导航方式」。</p>
          <p>公开的 DeepSeek Harness 有很好的会话、工具、运行状态观察能力，但<strong>没有看到一套完整公开实现，专门负责「长期失败归因 → 环境弱点诊断」</strong>。现在的状态更像「如果 AI 已经决定要改，我给你工具」，而不是「我会长期观察自己，自己发现该改哪里」。</p>
        </div>
        <div class="gap">
          <h4>缺口二 · 新的真的更好吗？ <span class="tag">缺：裁判</span></h4>
          <p>AI 写了一个规划模块 V2，跑起来了——这最多只能证明它没当场炸，不能证明 V2 比 V1 好。可能复杂任务成功率高了 2%，但花销翻倍、简单任务反而变差。真正的自我进化一定还需要一个「裁判」：旧的 vs 新的，分别跑一轮考试，比较成功率、成本、速度、安全、泛化，然后才决定：保留，还是回滚。<strong>这部分目前也没有形成完整闭环。</strong></p>
        </div>
        <div class="gap">
          <h4>缺口三 · 好东西现在还留不下来 <span class="tag">缺：转正机制</span></h4>
          <p>官方说明写得很清楚：<strong>动态零件只存在当前进程的内存里</strong>——不会变成正式的插件文件、不会安装、不会改配置、重启就没了、不能自动晋升成长期能力。进程一重启，实验就归零。这个设计很合理（现在明显还是实验室阶段），但未来如果真想自我进化，一定会多一步：临时能力 → 多次证明有效 → 转正 → 变成正式能力。也就是从「我刚才临时想的招」变成「以后我真的学会了」。</p>
        </div>
      </div>

      <div class="callout warn">
        <span class="ct-label">一句话总结现状</span>
        <p>DeepSeek Harness 目前是「<strong>如果 AI 已经决定要改，我给你工具</strong>」，而不是「我会长期观察自己，自己发现该改哪里」。自我进化，仍是一个未完成的循环。</p>
      </div>
    </section>

    <section id="s12">
      <h2><span class="secnum">12</span>一条一脉相承的思路</h2>
      <div class="thesis"><b>一句话论点</b>从 R1 用强化学习让推理能力自己长出来，到 Harness 让工作方式可以被改写——DeepSeek 的路线一以贯之：少一点写死，多一点让系统自己找到方法。</div>
      <p>回头看 DeepSeek-R1，会发现一个挺有意思的相似点。<strong>R1-Zero 最有意思的地方，不是「它会写很长的推理过程」，而是 DeepSeek 在基础模型上直接做大规模强化学习，没有先用人写的标准答案把一整套推理模板塞进去。</strong>官方说明特别强调：在这个过程中，模型自己长出了自我验证、自我反思、长推理等行为。</p>
      <p>当然，R1-Zero 也不是完美的——它会重复、可读性差、语言混杂，所以后来的 R1 又加入了一些标准数据和分阶段训练。但这条路线背后的审美很明显：<strong>有些方法，不一定要人一条条写死。可以给目标、给反馈，让系统自己探索出更有效的做法。</strong></p>
      <p>把这个思路搬到工作环境这一层，就会出现一个很自然的问题：今天这些东西——工具怎么配、提示词怎么组织、循环怎么跑、记忆怎么设计、什么时候派子代理——<strong>为什么一定永远由工程师手工规定？</strong>今天的工作环境，其实很像一种「手工策略」。未来会不会也有一部分变成：真实任务 → 结果反馈 → 尝试不同组合 → 更好的留下？</p>
      <pre><code>手工搭好的环境（人一条条写死）
        ↓ ？
从反馈里学出来的环境（自己长出来）</code></pre>
      <p>这才是 DeepSeek Harness 和「持续学习」真正值得联系的地方——不是因为 DeepSeek 在说明文档里写了「自我进化」（它没有），而是因为它正在把<strong>一个前提条件</strong>做出来：让工作环境先变成一个 AI 有机会观察和修改的对象。</p>
      <p>把 DeepSeek 公开过的东西放在一起看，有一条比较连贯的线：</p>
      <div class="tablewrap">
        <table>
          <thead><tr><th>阶段</th><th>重点</th><th>隐含的思路</th></tr></thead>
          <tbody>
            <tr><td class="mono">DeepSeek-V2 / V3</td><td>模型结构、训练效率、推理效率</td><td>怎么用更低成本做出更强模型</td></tr>
            <tr><td class="mono">DeepSeek-R1</td><td>强化学习让推理行为自己长出来</td><td>行为不必手写，给反馈即可</td></tr>
            <tr><td class="mono">DeepSeek Harness (2026)</td><td>工作环境可观察、可拆卸、可试验</td><td>AI 的工作方式也不必写死</td></tr>
          </tbody>
        </table>
      </div>
      <p>这三件事并不是同一个研究项目，不能硬说 V2 → R1 → Harness 是一条官方定义好的路线。但放在一起看，它们至少体现了一种相似的倾向：<strong>少一点永久写死的东西，多一点可以通过计算、反馈和运行结果找到的方法。</strong></p>
    </section>]]></content:encoded>
      <category>AI 深度拆解</category>
      <pubDate>Fri, 14 Aug 2026 09:07:27 GMT</pubDate>
    </item>
  </channel>
</rss>