Agent = Model + Harness：从公式到 RSI，智能体的三层本质Agent = Model + Harness: the harness decides what your model can do

Agent 不是更强的模型，而是「模型能力」与「执行编排系统」耦合后涌现的可行动系统。理解 Model、Harness、Agent 三者的本质关系，是判断一切 Agent 工程的起点。

---

01 / 核心公式：Agent = Model + Harness

Agent 是「模型 + Harness」结合后产生的可工作实体。Harness 单独存在时只是基础设施，加上模型之后才构成 Agent。

需要先划清两个容易混淆的概念：

• Framework（框架） 是构建 Agent 的积木库（如 LangChain），只是零件。

• Harness（马具 / 运行系统） 则是已经组装好、带有默认配置和完整运行时的系统。

核心逻辑是：

• Model（模型） 提供原始智能：处理文本、生成 token、进行推理。但裸模型是无状态的，没有工具、没有记忆、无法读写文件、不能执行命令。

• Harness（马具 / 运行系统） 是模型之外的一切：上下文管理、工具调用接口、记忆机制、沙箱执行、权限控制、评估钩子、子 Agent 编排等。它让裸模型从一个「只会聊天的引擎」变成一个真正能干活的 Agent。

业界共识是 Agent = Model + Harness。但要警惕一个错误表述：「Harness = Model + Agent」是错的 —— 因果方向反了，Harness 是先于 Agent 存在的运行外壳，不是由 Agent 反推出来的组件。

但这个公式太扁平，掩盖了三者真正的张力。更准确的理解是一个三层嵌套结构：

┌─────────────────────────────────────────┐
│              Agent                      │
│   ┌───────────────┐   ┌───────────────┐ │
│   │    Model      │   │   Harness     │ │
│   │  （智能内核）  │ ← │ （运行外壳）   │ │
│   └───────────────┘   └───────────────┘ │
│          ▲                    ▲          │
│          └──── 循环交互 ──────┘          │
└─────────────────────────────────────────┘

Model 和 Harness 不是并列相加，而是内核与外壳的耦合。Agent 是这种耦合在运行中涌现出的行为主体。

02 / 三者的本体论定位

把三者的本质并排看，差异一目了然：

• Model —— 本质是概率函数，回答「可能是什么」，无状态、被调用，类比 CPU。

• Harness —— 本质是控制系统，回答「允许做什么、怎么判定」，有状态、持续运行，类比操作系统。

• Agent —— 本质是行为主体，回答「实际做了什么」，有轨迹、涌现式存在，类比正在运行的程序。

关键洞察可以用「势能 — 结构 — 动能」来概括：

• Model 是「势能」—— 拥有海量可能性，但自身不会定向释放。

• Harness 是「势能的引导结构」—— 决定哪些可能性被激活、被允许、被记录、被评判。

• Agent 是「动能」—— 势能在结构中释放后产生的实际行为。

03 / 三个不对称关系

1. Model → Harness：能力供给，但不可控。 Model 提供理解、推理、生成，但它有三个致命缺陷：

• 无状态：每次调用都是全新的，不记得上一秒。

• 无身体：不能读写文件、不能执行命令、不能访问网络。

• 无边界感：不知道自己该停在哪、什么不能做。

所以 Model 是强大的但盲目的。它像一颗高能燃料，能量巨大，但不会自己造发动机。

2. Harness → Model：约束与赋能，同时进行。 Harness 对模型做的事情是双向的：

• 赋能（让模型能做到它单独做不到的事）：注入上下文给模型「记忆」；提供工具给模型「手脚」；编排循环给模型「持续行动的能力」。

• 约束（让模型不能做它不该做的事）：结构化输出限制表达空间；权限边界限制行动范围；步数 / 超时限制资源消耗；评估断言限制「自说自话」。

这是 Harness 最深刻的本质：它同时是模型的外骨骼和牢笼。没有它，模型无力；没有它，模型也失控。

3. Model + Harness → Agent：不是加法，是耦合涌现。 Agent 的本质是一个循环：

Harness 构造上下文 → Model 生成决策 → Harness 执行并观测
→ Harness 把结果写回上下文 → Model 再次决策 → ...

这个循环里，Model 贡献方向，Harness 贡献记忆、边界和反馈，两者耦合后涌现出的连续目标导向行为，才叫 Agent。所以 Agent 是动词，不是名词 —— 它是「模型在 Harness 中持续运行」这件事本身。

04 / 一句话本质

Model 是智能的来源，Harness 是智能的容器与裁判，Agent 是智能在容器中循环运行后涌现出的行为。

再压缩一层：Model 提供「能」，Harness 提供「可」，Agent 是「能」在「可」的边界内持续转化为「做」。

05 / 为什么这个区分是本质的

它解释了「同一个模型，为什么 Agent 效果天差地别」。 Agent 的表现不取决于 Model 单独多强，而取决于：Harness 给模型看什么（上下文质量）、让模型做什么（工具设计）、怎么判断模型做得好不好（评估反馈）、怎么防止模型跑偏（约束机制）。Model 决定上限，Harness 决定实际达到多少上限。

它解释了「为什么模型越强，Harness 越重要而不是越不重要」。 直觉上会以为模型变强了，外面的脚手架就可以简化，实际相反：

• 模型越强，能做的事越多 → 越需要权限边界。

• 模型越强，行动链越长 → 越需要记忆与轨迹管理。

• 模型越强，越可能「自作主张」→ 越需要评估与回滚。

• 模型越强，越能利用好工具 → 工具接口设计价值越大。

模型能力增长，会把瓶颈从「智能」转移到「可控性」，而可控性正是 Harness 的领域。

它解释了「Agent 工程」到底在工程什么。 Agent 工程 ≈ Harness 工程：写 prompt 是上下文层，定义工具是接口层，设计循环是控制层，做评估是裁判层，加沙箱是安全层。模型是买来的或训好的，Harness 才是工程师真正构建的东西。Agent 是 Harness 工程的产出，不是模型本身的属性。

06 / RSI 之后：谁才是真正的控制主体

当 Agent 具备 RSI（自我改进）能力后，问题升级了：谁才是真正的「控制主体」？RSI 让 Agent 从「会行动」走向「会改进自己」，但控制不等于某个单点，而是系统级闭环。

先分清三个层次，别混淆：

• 智能（Intelligence） 是一种能力：会解释、推理、生成。

• Model 是智能的承载体 / 核心引擎。

• Harness 是让能力接入现实世界的闭环基础设施。

• Agent 是能在环境中持续感知、决策、行动、反思并改进的系统主体。

一句话：智能是能力，Agent 是能力被组织起来后的行动系统。 智能加目标管理、工具、记忆、反馈循环，才等于 Agent。

RSI 元闭环（自我改进循环）让 Agent 不仅执行任务，还能递归提升「自己完成任务的方式」：观察自身表现 → 诊断瓶颈 → 修改技能（Prompt / Workflow / Tool Policy / Memory Policy）→ 重新部署并继续执行 → 状态更新、环境反馈、日志观测。此时 Agent 已经带上了「感知—决策—行动」之外的新环：「感知—决策—改进」。

那么控制主体到底是谁？

• 不是 Model 单独控制：Model 更像认知引擎 / 决策生成器，它产生判断，但通常不维护完整状态，也不具有执行责任。

• 不是 Harness 单独控制：Harness 更像神经系统 + 操作系统，它负责调度与约束，但本身不是智能判断的来源。

• Agent 才是功能上的主体：Agent 作为系统级主体，调用 Model 的能力，借助 Harness 组织执行，并基于结果实施模型或外部常规操作行为。

• 结论：控制是系统性的，主体是 Agent —— Model 是认知核心，Harness 是执行框架。

07 / 最终总结

• Model（智能内核） —— 提供可能性，但无方向、无记忆、无身体。

• Harness（运行外壳） —— 提供方向、记忆、身体、边界和裁判。

• Agent（行为主体） —— Model 在 Harness 中循环运行后涌现的目标导向行为。

三者的本质逻辑：Model 是「能」，Harness 是「可」，Agent 是「能」在「可」中持续转化为「做」的过程。

所以最终公式是：Agent = Model × Harness，不是加法，是耦合。 乘号代表：任何一方为零，Agent 都不存在；任何一方变强，Agent 都被放大 —— 但放大的方向，由 Harness 决定。

当 Agent 具备 RSI 后，「Agent = 智能」仍然不准确；更准确的表述是：Agent = 被组织、可执行、可反馈、可自我改进的智能系统。 它不是单纯由 Model 或 Harness 控制，而是以 Agent 整体作为对外行动主体。

---

延伸阅读：Y 站领域页「Agentic」栏目；技术雷达 Agentic 赛道。

An agent is not a stronger model. It is what emerges when model capability couples with an execution harness, and getting that distinction right is the starting point for every decision in agent engineering.

---

01 / The core formula: Agent = Model + Harness

An agent is the working entity you get when a model meets a harness. A harness on its own is just infrastructure. Add a model and you have an agent.

Two terms get conflated here, so separate them first:

• Framework — a parts library for building agents, LangChain being the obvious example. Components, nothing assembled.

• Harness — an assembled system with defaults and a complete runtime: everything that wraps a model, meaning context, tools, the loop, evaluation and sandbox.

The division of labour then reads like this:

• Model supplies raw intelligence. It handles text, emits tokens, reasons. A bare model is stateless: no tools, no memory, no file reads or writes, no command execution.

• Harness is everything else: context management, tool-call interfaces, memory mechanisms, sandboxed execution, permission control, evaluation hooks, sub-agent orchestration. It is what turns a conversational engine into something that does work.

The industry has converged on Agent = Model + Harness. Watch out for the reversed formulation, Harness = Model + Agent, which is simply wrong: the harness exists before the agent as a runtime shell, not as a component inferred backwards from one.

The formula is also too flat, and flatness hides the real tension between the three. A nested structure describes it better:

┌─────────────────────────────────────────┐
│                  Agent                  │
│   ┌───────────────┐   ┌───────────────┐ │
│   │     Model     │   │    Harness    │ │
│   │  (cognition)  │ ← │   (runtime)   │ │
│   └───────────────┘   └───────────────┘ │
│           ▲                   ▲         │
│           └────── loop ───────┘         │
└─────────────────────────────────────────┘

Model and Harness do not sit side by side and add up. They couple, as core and shell. The agent is the acting subject that coupling produces while it runs.

02 / Ontological status of the three

Put the three side by side and the differences are hard to miss:

• Model — a probability function at bottom. It answers "what could this be". Stateless, invoked. Comparable to a CPU.

• Harness — a control system. It answers "what is allowed, and how is it judged". Stateful, always running. Comparable to an operating system.

• Agent — an acting subject. It answers "what actually got done". Has a trajectory, exists emergently. Comparable to a running program.

Potential, structure, kinetic — that is the compact version:

• Model is potential energy — a vast field of possibility that cannot discharge itself in any direction.

• Harness is the structure that channels it — deciding which possibilities get activated, permitted, recorded and judged.

• Agent is kinetic energy — the actual behaviour released once potential discharges through that structure.

03 / Three asymmetric relations

1. Model to Harness — capability supplied, controllability not. The model delivers comprehension, reasoning and generation, and it carries three fatal gaps:

• Stateless: every call starts fresh, with no memory of the last second.

• Bodiless: it cannot read or write files, run commands or reach the network.

• No boundary sense: it does not know where to stop or what is off limits.

The model is powerful and blind. It is high-energy fuel that cannot build its own engine.

1. Harness to Model — constraining and enabling at the same time. What the harness does to the model runs in both directions:

• Enabling, so the model can do what it cannot do alone: injecting context gives it memory, exposing tools gives it hands, running the loop gives it sustained action.

• Constraining, so the model cannot do what it should not: structured output narrows its expressive space. Permission boundaries narrow its range of action. Step and timeout caps bound resource use. Evaluation assertions stop it from declaring success on its own say-so.

This is the deepest thing about a harness: it is the model's exoskeleton and its cage simultaneously. Without it the model is powerless; without it the model also runs wild.

1. Model plus Harness to Agent — not addition, coupled emergence. The substance of an agent is a loop:

Harness assembles context → Model produces a decision → Harness executes and observes
→ Harness writes the result back into context → Model decides again → ...

Inside that loop the model contributes direction and the harness contributes memory, boundaries and feedback. The continuous goal-directed behaviour that emerges from the coupling is what we call an agent. An agent is a verb, not a noun — it is the event of a model running inside a harness.

04 / The one-line essence

The model is the source of intelligence, the harness is its container and its judge, and the agent is the behaviour that emerges once intelligence circulates inside that container.

One level tighter: the model supplies can, the harness supplies may, and an agent is can turning into does, continuously, inside the bounds of may.

05 / Why this distinction is fundamental

It explains why the same model produces wildly different agent results. Performance does not track how strong the model is in isolation. It tracks four things: what the harness shows the model (context quality), what it lets the model do (tool design), how it decides whether the work was any good (evaluation feedback), and how it keeps the model from drifting (constraint mechanisms). The model decides the ceiling; the harness decides how much of that ceiling you reach.

It explains why stronger models make the harness more important, not less. The intuition says that as models improve the scaffolding around them can get simpler. The opposite happens:

• More capable means more it can do, so permission boundaries matter more.

• More capable means longer action chains, so memory and trajectory management matter more.

• More capable means more initiative you did not ask for, so evaluation and rollback matter more.

• More capable means better tool use, so interface design is worth more.

Growing model capability moves the bottleneck from intelligence to controllability, and controllability is the harness's territory.

It explains what agent engineering actually engineers. Agent engineering is harness engineering: prompts are the context layer, tool definitions the interface layer, the loop the control layer, evaluation the judge layer, the sandbox the safety layer. The model is bought or trained. The harness is what your engineers actually build. An agent is the output of harness engineering, not a property of the model.

06 / After RSI: who is actually in control

Give an agent recursive self-improvement (RSI) and the question escalates: who is the controlling subject? RSI takes an agent from being able to act to being able to improve how it acts. Control here is not a single point. It is a system-level loop.

Four levels, which are easy to collapse into each other:

• Intelligence is a capability: explaining, reasoning, generating.

• Model is the carrier of that capability, the core engine.

• Harness is the closed-loop infrastructure that connects capability to the real world.

• Agent is the system subject that perceives, decides, acts, reflects and improves, continuously, inside an environment.

In one line: intelligence is a capability; an agent is that capability organized into an acting system. Intelligence plus goal management, tools, memory and feedback loops is what equals an agent.

The RSI meta-loop takes an agent past executing tasks. It recursively improves the way it executes them: observe its own performance, diagnose the bottleneck, modify its skills (prompt, workflow, tool policy, memory policy), then redeploy and continue, picking up state updates, environment feedback and log observations. A second ring closes on top of perceive-decide-act: perceive-decide-improve.

So who controls it?

• Not the model alone. The model is a cognitive engine, a generator of decisions. It produces judgements, but it generally holds no complete state and carries no execution responsibility.

• Not the harness alone. The harness is nervous system and operating system in one. It schedules and constrains, but it is not the source of intelligent judgement.

• The agent is the functional subject. As a system-level subject it draws on model capability, organizes execution through the harness, and acts on the results.

• Control is systemic; the subject is the agent. The model is the cognitive core and the harness is the execution framework.

07 / Final summary

• Model, the intelligence core — supplies possibility, but with no direction, no memory and no body.

• Harness, the runtime shell — supplies direction, memory, a body, boundaries and a judge.

• Agent, the acting subject — the goal-directed behaviour that emerges once a model runs in a loop inside a harness.

Put together: the model is can, the harness is may, and the agent is can becoming does inside may.

So the final formula is Agent = Model × Harness, multiplication rather than addition. The sign carries two claims: if either side is zero there is no agent at all, and if either side grows the agent is amplified — but the harness decides the direction of that amplification.

Even after RSI, saying "agent = intelligence" is still wrong. The accurate phrasing is: an agent is an intelligent system that is organized, executable, feedback-capable and self-improving. It is not controlled by the model or by the harness in isolation. The agent, as a whole, is the subject that acts outward.

---

Further reading: the Agentic field page on Y, and the Agentic track on the Tech Radar.