从大模型到 Agent：MCP、SKILL，以及 DeepSeek Harness 为什么是一个 Agent

你在聊天框里敲下一句：”帮我把这个 PR 里改动的文件跑一遍单测，失败的整理成报告发我。”

这不是一句”问答”，而是一份”委托”：它要求 AI 先读懂你的意图，再去翻代码、找到改动、拼出测试命令、在沙箱里执行、解析失败信息、最后汇总成报告。任何一个环节都超出了”聊天机器人”的能力边界。

过去两年，AI 圈最热的一批词——大模型（LLM）、Agent、MCP、SKILL——正是在描述”怎么让模型真正把这件事干成”的不同侧面。它们常被混用，但它们各司其职：一个是大脑，一个是人，一个是插座，一个是说明书。

这篇文章会用与之前 Dubbo Triple、ZooKeeper、MCP 系列相同的剖析风格，回答三个问题：

1. 是什么：大模型、Agent、MCP、SKILL 各自的本质与边界，以及它们周边还有哪些容易混淆的概念。
2. 怎么拼：这四者（以及工具、记忆、沙箱、审批）如何拼成一个能真正干活的 Agent。
3. 实证：DeepSeek Harness 为什么是一个 Agent（准确说，是一个 agent harness），逐条对照它的真实架构。

一、大模型：一个没有手脚、没有记忆、没有目标的大脑

1.1 本质：一个纯函数

大语言模型（Large Language Model，LLM）本质是一个函数：

f(tokens) -> tokens

输入一串 token，输出一串 token，仅此而已。它没有”副作用”——不能读文件、不能查数据库、不能发 HTTP 请求、不能执行命令、不能计时。你在界面上看到它能”读你的文件”，那是外面包的那层壳在干活，不是模型本身。

1.2 三大短板

把 LLM 直接丢到真实任务面前，它有三个天生缺陷：

1.3 结论

LLM 是”能力内核”，不是”应用”。它像一个天赋极高但被关在隔音房里的大脑：会思考、会表达，但既碰不到外界，也记不住上一句话。要让这颗大脑干活，必须给它装上手脚、记忆和目标——这层”壳”，就是 Agent。

二、Agent：给大脑装上手脚、记忆与目标

2.1 一句话定义

Agent = 大模型 + 工具 + 记忆 + 目标，并且跑在一个循环里。

这个定义很朴素，但几乎所有的 Agent 框架，拆到最底层都是这四样东西。缺了任何一样，都只能叫”带工具调用的聊天”，而不是 Agent。

2.2 核心：Agentic Loop

Agent 与”单次问答”最本质的区别，在于它运行在一个循环里：

        ┌──────────────────────────────────────────────┐
        │                  Agent Loop                   │
        │                                               │
 输入 ──▶│ 感知(Perceive) ──▶ 思考(Think / Plan)          │
        │      ▲                  │                     │
        │      │                  ▼                     │
        │      │          行动(Act：调用工具 / MCP)        │
        │      │                  │                     │
        │      └──── 观察(Observe：工具结果喂回模型) ──────┘
        │                         │                     │
        └─────────────────────────┼──▶ 输出 / 进入下一轮   │
                                  │                     │
                          目标达成？否 ──▶ 继续循环        │
                          目标达成？是 ──▶ 结束            │

循环的每一步都清晰：模型思考该做什么 → 决定调用哪个工具 → 工具执行产生副作用 → 结果作为新的输入观察 → 模型再思考。这个”感知—思考—行动—观察”的闭环，就是 Agent 区别于”一次性补全”的全部秘密。

2.3 四块积木逐一拆开

（1）大脑：LLM

负责理解意图、做规划、决定调用什么工具、生成自然语言。它是循环里唯一会”思考”的部分。

（2）手脚：工具（Tool / Function Calling）

模型不会真的”点鼠标”，它做的是函数调用（Function Calling）：

1. 运行时把每个工具的"说明书"（名称、描述、参数 JSON Schema）拼进请求
2. 模型输出一个"工具调用"：调哪个函数、传什么参数
3. 运行时真正执行这个函数，拿到结果
4. 结果作为一条新消息喂回模型，继续下一轮

工具是”动作”的原子单位。MCP 和 SKILL，本质都是在给”工具/能力”这一层做标准化（后文详述）。

（3）记忆：上下文、上下文窗口与长期记忆

模型每次推理的”工作记忆”是上下文（Context），它的容量上限叫上下文窗口（Context Window）。窗口是有限的，而任务常常无限长，于是衍生出一整套工程手段：

• Prompt / System Prompt：喂给模型的角色设定与指令，是”记忆”里最稳定的那部分（”你是谁、要遵守什么规则”）。
• Compaction（上下文压缩）：当对话逼近窗口上限时，把历史压缩/摘要，给新信息腾地方。
• 长期记忆（Memory）：跨会话的持久化存储，把”这次学到的东西”留给下次用。

（4）目标：知道”什么时候算干完”

聊天没有目标，Agent 有。目标决定了循环何时继续、何时停止，也是”自主多轮推进”（autonomous loop）的前提。一个有目标的 Agent，可以在没人每轮都盯着的情况下，连续多轮工作直到完成——这也是它最容易”跑飞”、最需要护栏的地方。

2.4 两个容易被忽略的护栏

沙箱（Sandbox）：既然 Agent 要执行代码、读写文件、跑命令，就必须把它关在隔离环境里，防止它误删宿主机、泄露密钥。沙箱不是可有可无，而是 Agent 能”放心地自动干活”的前提。

人在环中（Human-in-the-loop / 审批）：对删除文件、发起支付、合并代码这类不可逆动作，插入人工确认。它用”一道人的关卡”换取”模型可以更大胆地自主行动”。

2.5 一个常见误区

很多人以为”模型更强了”就等于”这是 Agent 了”。其实 Agent 是一个工程架构，不是模型的某种属性。同一个模型，放进一个有循环、有工具、有目标、有记忆的运行时里，就是 Agent；放进一个”一问一答”的聊天框里，就只是聊天机器人。

三、MCP：给”工具接入”定一个标准插座

3.1 一句话定位

MCP（Model Context Protocol）是模型与外部世界之间的标准协议，是”AI 的 USB-C 接口”。

2024 年 11 月 Anthropic 开源了它，如今已是事实上的行业标准（关于它的类型、原理与使用方式，我在上一篇《MCP 全面解析》里拆过，这里只讲它在全景图里的坐标）。

3.2 它解决的是 N×M 困境

没有标准时，M 个模型 × N 个工具 = M×N 套适配器。MCP 把”工具怎么描述、怎么发现、怎么调用”统一成一套协议：

模型 A ──┐                     ┌── 文件系统
模型 B ──┼── MCP 协议 ──▶  MCP Server ──┼── 数据库
模型 C ──┘                     └── GitHub / 浏览器 / ...

一个 MCP Server 把一组能力（工具 / 资源 / 提示词）按标准暴露出来，任何支持 MCP 的客户端都能即插即用。

3.3 MCP 在 Agent 里的位置

注意：MCP 是”能力接入层”，不是 Agent 本身。 它解决的是”工具怎么插上”，而不是”循环怎么转、目标怎么定、记忆怎么存”。把 MCP Server 接进聊天框，得到的是一个”带工具调用的聊天”，要变成 Agent，还需要上面第二节的那套循环与目标。

四、SKILL：给”知识和方法”定一个按需查阅的手册

4.1 一句话定位

SKILL 是把可复用的指令、流程、领域知识打包成一张”技能卡片”，需要时按需加载进上下文。

它通常是一个带 frontmatter 的 Markdown 文件（如 SKILL.md 或 <name>.md），开头声明 name、description，正文写清”这件事该怎么做”。

4.2 它解决的是”知识海量 vs 窗口有限”

上下文窗口是有限的，但你不可能把所有知识都常驻在里面。SKILL 的思路是分治 + 按需：

目录里只放一句话简介（省 token）
       │
       ▼  模型判断"这个任务正好用得上"
按需加载 SKILL 的完整正文
       │
       ▼
正文作为指令注入当前上下文，指导后续行动

模型看到的是”技能目录”，真正用到时再取全文——用一个很小的常驻成本，换来了近乎无限的可扩展知识库。

4.3 SKILL 与 MCP 的分工：一个给说明书，一个给手脚

这俩最容易混。一句话划清：

一个更完整的对照（含常被混进来的两个）：

五、一张全景图：四者如何拼成一个 Agent

5.1 分层模型

┌────────────────────────────────────────────────┐
│             Agent（控制层）                      │
│   循环(Loop) · 目标(Goal) · 记忆(Memory)          │
│   沙箱(Sandbox) · 审批(Human-in-the-loop)        │
│                                                │
│   ┌──────────────┐      ┌──────────────┐       │
│   │  动作 / 能力   │      │  知识 / 方法   │       │
│   │   (MCP/Tool) │      │   (SKILL)    │       │
│   └──────────────┘      └──────────────┘       │
│                                                │
│   ┌──────────────────────────────────────┐     │
│   │        大模型 LLM（内核）               │     │
│   │        f(tokens) -> tokens           │     │
│   └──────────────────────────────────────┘     │
└────────────────────────────────────────────────┘

自下而上：LLM 提供”思考”，MCP/Tool 提供”手脚”，SKILL 提供”方法”，Agent Loop 把三者串成一个带目标、带记忆、带护栏的循环。

5.2 一个真实任务走一遍

以开头那句”跑单测并整理失败报告”为例，每一层的角色一目了然：

1. 目标(Goal)        : "跑测试 → 汇总失败 → 出报告"，循环据此判断何时结束
2. 思考(LLM)         : 决定"先读改动，再拼命令"
3. 方法(SKILL)       : 加载"跑单测"技能，得知项目的测试命令约定
4. 手脚(Tool/MCP)    : 调用 read_file、bash 等工具真正读文件、执行命令
5. 护栏(Sandbox)     : 测试命令在隔离沙箱里执行，不污染宿主
6. 观察(工具结果)     : 测试输出喂回模型，模型解析失败项
7. 循环(下一轮)      : 还有失败的？定位原因、补跑，直到报告完整

六、DeepSeek Harness：为什么它是一个 Agent

6.1 它是什么

DeepSeek Harness（命令行工具 dsh）是 DeepSeek AI 开源的 agent harness（智能体框架）。它有一句贯穿全局的设计主张：

一切皆插件（everything is a plugin），由 Cordis 驱动。

这句话的分量，要到最后才能体会：在 dsh 里，连”模型适配器、工具注册表、会话日志、Agent 循环本身“都是插件，都能从配置里被替换。

6.2 逐条对照 Agent 定义

把第二节的”Agent = 大模型 + 工具 + 记忆 + 目标 + 循环”逐条映射到它的真实架构：

6.3 循环怎么转：turn 与 step

dsh 把 Agent 的循环拆成两个层级：一个 step 是”一次模型请求 + 它引发的工具调用”；一个 turn 是”零到多个 step”，从有输入被认领开始，到没有待办为止结束。核心流程（摘自架构文档）：

turn/start
  认领下一轮输入 + 一条排队消息
  拼装 prompt 段 + 工具 schema
  -> agent/pre-step           拒绝 | 进入(messages)
     step/start
     追加进入的消息为 user/message
     从日志派生模型历史
     agent/request -> llm/stream -> assistant/chunk* -> assistant/message
     tool/call* -> tools/pre-execute -> tools/execute -> tools/post-execute -> tool/result*
     step/end
     工具还欠一次请求，或下一轮输入已到 -> 认领 -> 下一个 step
  -> agent/turn-stopping
turn/end

注意两件事。其一，工具调用是”守卫式管线”：pre-execute → execute → post-execute 层层可拦截，这就是审批、超时、策略等护栏挂载的地方。其二，模型能看到的一切都来自会话日志——架构里有一条硬不变量叫”模型可见 ⟺ 已记录（model-visible ⟺ logged）“，任何要进入模型请求的东西都必须能从日志里重建出来。这条不变量同时解决了可回放、可审计、可持久化三件事。

6.4 为什么说它是 Agent，而不是”一个 Agent”

到这里可以回答标题了。DeepSeek Harness 之所以是一个 Agent，是因为它完整具备 Agent 的全部要件；而它之所以叫 harness 而不是”一个写死的 Agent”，是因为：

• 循环是插件：agent-loop 只是默认驱动，挂在扩展点上，可以被替换；
• 能力是”接缝”（capability seam）：文件系统、Shell、子进程、LSP、Web、Skill、Subagent……每一项能力都按”Service Definition / Service Provider / Consumer”三角色设计，换一个 Provider（比如把本地 Shell 换成远程沙箱）就整体换掉了整条能力；
• 可组合：一次运行是一棵”插件树”，通过 profile / bundle / patch 分层叠加，任何一行配置都能被上面的层覆盖；
• 可观测：会话日志 + 事件（agent/*、tools/*、turn/*、step/*）既是扩展点，也是审计面。

所以更准确的说法是：DeepSeek Harness 是一个可插拔、可组合、可观测的”Agent 工厂/运行时”——你用它组装出一个个具体的 Agent，而不是它本身就只是一个 Agent。

6.5 MCP 与 SKILL 在 dsh 里的落点

• MCP 那一层对应它的”能力接缝”体系：每一项能力都是标准化的三件套，MCP Server 可以作为一种 Provider 接进对应接缝，从而把外部能力以统一方式变成 Agent 可调的工具。
• SKILL 那一层对应它的 skill 体系：ctx.skills 是 skill 的注册表，dsh-skill-filesystem 是本地 Provider（扫描 .dsh/skills、.agents/skills 等目录），而 dsh-tool-skill 则是面向模型的 Consumer——它把”技能目录”渲染给模型，并提供 skill 工具让模型按需加载某个技能的完整正文。SKILL 在这里被明确视作”可选指令，而非会话事件”。

七、总结

一句话记住四者：

大模型 LLM   = 大脑     （会思考，没手脚）
Agent       = 人       （大脑 + 手脚 + 记忆 + 目标 + 循环）
MCP         = 插座     （把工具统一成标准协议）
SKILL       = 说明书   （把知识和方法打包成按需查阅的手册）

判断一个东西”是不是 Agent”，可以套用这个 checklist：它有没有循环（多轮、有反馈闭环）？有没有工具（能产生副作用）？有没有记忆（上下文与持久化）？有没有目标（知道何时算完成）？有没有护栏（沙箱与审批）？五条都满足，它才是 Agent；否则，它多半只是”带工具调用的聊天”或”带知识检索的补全”。

DeepSeek Harness 之所以是 Agent，是因为它把上述每一条都做成了可替换的插件——连循环本身都不例外。这正是”harness”二字的含义：它不是某个具体的智能体，而是制造智能体的那套可组合骨架。

附录：一张全景词表

与大模型/Agent 相关、容易混用的概念，按”离 Agent 远近”归个档：

第一档 · 就在 Agent 内部

第二档 · 协议与标准

第三档 · 模型侧 / 训练侧（一般一笔带过）

第四档 · 同类框架

LangChain、LlamaIndex、Semantic Kernel、AutoGen 等，与 DeepSeek Harness 是”同一类问题的不同解法”，区别在于各自的组合哲学——dsh 的答案是”一切皆插件 + 可替换的能力接缝”。