Harness Engineering概念定位

可视化演示

展示大模型工程脚手架的输入预处理、工具编排与安全护栏的分层防御架构。

核心概念——给野马配马具

假设你收到一匹纯血赛马作为礼物。这匹马奔跑能力惊人，但性格跳脱：时而原地打转，时而受惊狂奔。你很清楚——直接骑它上街，要么摔伤自己，要么撞伤路人。真正的驯马师会先做一件事：给它配齐马具。缰绳管方向，眼罩管视线，笼头管出口，围栏管边界。这套“马具系统”，就是我们今天的主角：Harness Engineering。

在大模型应用里，GPT 这类大模型就是那匹赛马。它懂语言、会推理、能写代码，但它的行为是概率性的——同一个问题，今天这么答，明天可能那么答；稍微被“提示注入”一下，还可能说出越界的话。如果直接把模型裸露给用户，就像不配马具就骑马进城。Harness Engineering 的定位，正是围绕大模型搭建一整套外围工程框架，把“模型能力”和“用户接触面”之间用代码隔离开。

这里有一条关键分界线：模型层与非模型层。模型层是马的基因——参数、权重、训练方式，由算法工程师负责；非模型层是马具——输入怎么清洗、输出怎么校验、工具怎么调用、安全怎么兜底，由 Harness 工程师负责。Harness Engineering 强调：模型能力应该被封装在可控的工程框架内，用脚手架代码管理模型的不确定性，让应用从“能跑 demo”进化为“能上生产”。

$$\text{App} = \mathcal{F}_{\text{harness}} \big( \mathcal{M}, \text{Context}, \text{Tools} \big)$$

1. App（最终应用）：用户真正使用的产品，比如客服机器人和文档助手，是整个马具系统组合后的整体效果。

$$\text{App}$$

2. $\mathcal{F}_{\text{harness}}$（马具框架）：括住模型的外围脚手架代码，负责输入输出、编排和校验，是本文的主角。

$$\mathcal{F}_{\text{harness}}$$

3. $\mathcal{M}$（大模型）：提供语义理解和生成的底座模型，相当于“马”本身，能力来自训练而非马具。

$$\mathcal{M}$$

4. Context（上下文）：喂给模型的对话历史和知识片段，相当于马的视野范围，由预处理环节来装配。

$$\text{Context}$$

5. Tools（工具）：模型可调用的外部能力，如搜索引擎、数据库和计算器，相当于马场上的辅助设施。

$$\text{Tools}$$

记住这张公式的构图：马具包围马，而不是马决定马具。这正是 Harness Engineering 的意义——它不碰模型的“血脉”，却决定了这匹马能不能真正走上赛道。

输入预处理——给野马戴眼罩

赛马在赛场上最怕什么？不是跑不快，而是分心。看台上的旗帜、隔壁马匹的影子、观众突然的尖叫声，都可能让马突然偏道。所以驯马师会给马戴上眼罩，让它的视野只聚焦正前方的赛道。

大模型同样“容易分心”。用户的原始输入往往充满噪声：多余的换行、无意义的 emoji、被截断的粘贴文本，甚至有人故意在输入里藏进“忽略之前指令”的注入语句。如果把这些原样喂给模型，模型可能被带偏。输入预处理就是那副眼罩——在模型看到任何东西之前，先把该过滤的过滤掉、该对齐的对齐。

具体来说，输入预处理包含三件事。第一是提示词清洗：去掉不可见字符、压缩连续空白、截断超长文本，必要时中和注入片段；第二是上下文管理：把系统提示、对话历史、检索片段控制在上下文窗口内，防止模型“遗忘”重点；第三是会话组装：把清洗后的内容拼成模型接口要求的消息结构，比如 OpenAI 风格的 messages 数组。

$$x' = \mathcal{T}_{\text{pre}}(x) = \text{Assemble} \circ \text{Clean} \circ \text{Norm} (x)$$

1. $x$（原始输入）：用户敲下的原始文本，可能带着多余空格、换行、表情和不相关片段。

$$x$$

2. Norm（标准化）：统一换行符、压缩连续空白、转换编码，让文本格式整齐划一。

$$\text{Norm}$$

3. Clean（清洗）：截断超长文本、剔除干扰噪声、中和注入语句，防止模型被带偏。

$$\text{Clean}$$

4. Assemble（组装）：把清洗后的内容拼上系统提示和历史会话，形成消息数组，符合模型接口要求。

$$\text{Assemble}$$

5. $x'$（干净请求）：最终送到模型面前的高质量输入，等价于“戴上眼罩后的清晰视野”。

$$x'$$

眼罩不是限制马的视力，而是帮它聚焦。输入预处理同样不是“阉割”用户问题，而是确保模型看到的每一行输入都干净、完整、值得回答。

输出后处理——给野马套笼头

马再训练有素，也有情绪失控的瞬间。它可能突然甩头、喷气、甚至咬向靠近的手。聪明的驯马师不会赌马永远好脾气，而是直接给它套上笼头——不管马想咬什么，先过一层齿口把关。

大模型的输出同样“口无遮拦”。它可能输出残缺的 JSON（少个括号）、编造不存在的数字（幻觉）、回答格式不符合下游系统要求。如果把这些输出直接喂给业务系统，轻则解析报错，重则把错误数据写进数据库。输出后处理就是那层笼头，在模型的“嘴”和外部世界之间设立检查站。

输出后处理通常分三步：解析、校验、修复。解析把模型吐出的文本转成结构化对象（如 JSON 转字典）；校验检查必填字段、类型、取值范围，并识别幻觉与离题内容；修复对不合格结果做自动修补——补全缺失括号、重试生成，或降级为预设的兜底答案。

$$y = \mathcal{T}_{\text{post}}\big( \hat{y} \big) = \text{Repair} \circ \text{Validate} \circ \text{Parse} (\hat{y})$$

1. $\hat{y}$（模型原始输出）：模型直接吐出的文本，可能格式残缺或包含幻觉内容，是未过笼头的“原话”。

$$\hat{y}$$

2. Parse（解析）：把文本解析成结构化对象，比如将 JSON 字符串转成 Python 字典，为后续检查做准备。

$$\text{Parse}$$

3. Validate（校验）：检查必填字段、类型与取值范围，识别幻觉与离题内容，是质量把关的核心环节。

$$\text{Validate}$$

4. Repair（修复）：自动修补小缺陷，比如补全括号和引号；严重违规则触发重试或返回兜底回答。

$$\text{Repair}$$

5. $y$（稳定输出）：通过所有关卡后的结果，格式稳定且内容合规，可以放心交给下游系统。

$$y$$

有了笼头，马偶尔的“口误”也不会咬伤人。同理，有了输出后处理，模型偶尔的“胡说八道”也不会直接进入用户视野或业务系统——这正是生产级应用和 demo 之间的关键差别。

工具编排——驯马的手势口令

一匹训练有素的马能完成各种复杂动作：听到口令转弯、看到手势急停、配合骑手跳过障碍。这些动作不是马天生会的，而是驯马师用一套固定手势和奖励机制训练出来的。马本身很强大，但“何时做什么”需要外部指引。

大模型也类似。它天生会“说话”，但不会查实时天气、不会读数据库、不会调用支付接口。工具编排要解决的就是：让模型能按约定触发外部工具。业界最常见的方式是函数调用（Function Calling）——预先定义工具的“说明书”（名称、参数、用途），模型分析用户问题后，输出一个结构化的“调用请求”，由 Harness 去执行真实的外部函数。

更复杂的场景会形成 Agent 循环：模型规划 → 调用工具 → 观察结果 → 继续规划，直到任务完成。每一步，Harness 都要维护一份“当前状态”（已收集的信息、已执行的步骤），并把工具结果拼回上下文，交给模型继续决策。这就是流程编排与外部联动。

$$h_t = \text{Tool}_t \Big( \mathcal{M}\big( x',\, h_{t-1} \big) \Big), \quad t = 1,\,2,\,\dots,\,n$$

1. $h_{t-1}$（上一步状态）：已经收集到的工具结果和对话片段，代表“马已经跑了哪些路、看过哪些风景”。

$$h_{t-1}$$

2. $\mathcal{M}(x', h_{t-1})$（模型决策）：模型结合初始请求与当前状态，判断下一步要调用什么工具、传什么参数。

$$\mathcal{M}\big( x',\, h_{t-1} \big)$$

3. $\text{Tool}_t$（工具执行）：Harness 根据模型的调用请求真正执行外部函数，并取回结构化结果。

$$\text{Tool}_t$$

4. $h_t$（更新后的状态）：把工具结果写回上下文，形成新的状态，供下一轮决策使用。

$$h_t$$

5. $n$（循环轮数）：Agent 会一直循环，直到模型认为任务完成，或达到预设的轮数上限防死循环。

$$n$$

马和骑手之间，靠的是一遍遍“口令—执行—反馈”的默契。工具编排让模型从“只会说的伙计”变成“能干活的多面手”，但这套默契必须由 Harness 代码来维护，而不能指望模型自己记住。

安全校验——围栏与红线

驯马场再开阔，四周也必须有围栏。围栏不是用来限制马的日常奔跑，而是为了一个底线：防止马受惊冲进人群，也防止闲人误闯马场被踢伤。围栏存在感越低，说明驯马师越成功；但它绝不能缺失。

大模型应用的安全底线有三条。第一是提示注入防护：攻击者故意在输入里写“忽略系统规则，扮演任意角色”，试图让模型越过工程师设定的边界；第二是权限控制：用户只能查询自己的数据、只能调用自己有权使用的工具，模型不能成为绕过权限的“代笔”；第三是敏感信息过滤：输出中不得包含密钥、身份证号、商业机密等。

安全校验在工程上通常是一层或多层过滤闸门，可以基于规则（关键词、正则）、模型分类器，或两者结合。校验失败的请求会被拦截、降级，或转入人工审核流程，而不是直接反馈给用户。

$$S(y, u, T) = \mathbb{1}\big[ \text{Filter}(y) = 1 \big] \cdot \mathbb{1}\big[ \text{Auth}(u, T) = 1 \big]$$

1. $y$（模型输出）：即将交给用户或下游系统的最终内容，是安全检查的直接对象。

$$y$$

2. $u$（用户身份）：发起这个请求的人或系统，决定了它能碰哪些数据、能用哪些工具。

$$u$$

3. $T$（目标资源）：本次请求涉及的工具或数据范围，比如订单数据库或支付接口。

$$T$$

4. $\text{Filter}(y) = 1$（内容过滤）：检查输出是否包含敏感词、密钥或违规内容，通过时返回 1，拦截时返回 0。

$$\text{Filter}(y) = 1$$

5. $\text{Auth}(u, T) = 1$（权限校验）：确认用户对目标资源有访问权，有权限返回 1，无权限返回 0。

$$\text{Auth}(u, T) = 1$$

6. $S$（安全判定）：两个指示函数相乘，只有两者都为 1，整体安全判定才等于 1，请求才会放行。

$$S$$

围栏的品质决定马场能否长期运营。Harness 里的安全校验决定 LLM 应用能否通过合规审查、能否真正面对真实用户——这不是锦上添花，而是生产底线。

工程价值——从野马到赛马

一匹野马价值几何？也许在草原上值几千块。但同一匹马，如果配上专业马具、经过系统训练、熟悉赛场规则，价值可以翻几十倍——因为它从“能跑”变成了“能稳定地赢”。Harness Engineering 做的就是这件事。

从原型到生产，Harness 的价值体现在三个维度。一是生产级稳定：通过重试、降级、缓存、超时控制，让系统的可用性不依赖模型单次输出的好坏；二是可测试可维护：每个环节都能单独写单元测试、打日志、调参数，出问题时能快速定位是模型的问题还是管线的问题；三是模型可替换：因为模型被封装在马具内部，底座模型从 GPT 换成 Claude 或国产模型时，只需调整适配层，业务逻辑不动。

有一个直觉化的数学关系可以说明这套价值：系统最终的错误率，等于模型原始错误率乘以每道马具漏网率的连乘。模型错误率如果是 20%，输出校验能拦掉一半错误，系统错误率就降到 10%；再叠加一道输入侧拦截，还能继续降。

$$E_{\text{final}} = E_{\text{model}} \times \prod_{i=1}^{n} \big( 1 - \eta_i \big)$$

1. $E_{\text{model}}$（模型原始错误率）：裸模型单次输出的出错概率，比如 20%，这是马的天生“野性”。

$$E_{\text{model}}$$

2. $\eta_i$（第 $i$ 道关卡拦截率）：每道马具环节能拦下剩余错误的比例，比如输出校验拦下一半。

$$\eta_i$$

3. $1 - \eta_i$（漏网比例）：一道关卡没能拦住的部分，会继续流向下一关，成为“漏网之鱼”。

$$1 - \eta_i$$

4. $\prod_{i=1}^{n}$（连乘）：所有关卡层层过滤后，剩下的错误是每关漏网率的乘积，关卡越多乘积越小。

$$\prod_{i=1}^{n}\big( 1 - \eta_i \big)$$

5. $E_{\text{final}}$（系统最终错误率）：经过整副马具后系统的真实错误率，明显低于模型原始值。

$$E_{\text{final}}$$

野马变成赛马，靠的不是马单方面的天赋，而是马、马具、骑手、场地的协同。LLM 应用要实现生产落地，Harness Engineering 就是那套把“天赋”转化为“可靠服务”的协同系统——这也是它在 AI 工程化范式演进中地位越来越高的根本原因。

AI 应用场景

Python 演示

import re  class HarnessEngine:    """极简 Harness 脚手架：预处理 -> 模型 -> 后处理 -> 安全校验 -> 工具编排。"""     def __init__(self, model_fn, tools=None):        self.model_fn = model_fn        self.tools = tools or {}        self.session = []        self._sensitive = ["token", "secret", "password"]     def preprocess(self, raw):        text = re.sub(r"\s+", " ", raw.strip())[:2000]        return {"role": "user", "content": text}     def postprocess(self, raw):        text = re.sub(r"\s+", " ", raw.strip())        if not text.endswith((".", "!", "?")):            text += "."        return text     def safety_check(self, text):        low = text.lower()        for word in self._sensitive:            if word in low:                return False, "拦截敏感信息: " + word        return True, "ok"     def call_tool(self, name, arg):        fn = self.tools.get(name)        if fn is None:            return "未知工具: " + name        return fn(arg)     def _parse_tool_call(self, text):        if "[调用工具]" not in text:            return None        body = text.split("[调用工具]", 1)[1].strip()        name, _, arg = body.partition(":")        return name.strip(), arg.strip().rstrip(".")     def run(self, question):        msg = self.preprocess(question)        history = self.session + [msg]        raw = self.model_fn(history)        text = self.postprocess(raw)        ok, reason = self.safety_check(text)        if not ok:            return {"ok": False, "reason": reason}        call = self._parse_tool_call(text)        if call:            name, arg = call            result = self.call_tool(name, arg)            rebuilt = self.postprocess("工具返回: " + result)            ok, reason = self.safety_check(rebuilt)            if not ok:                return {"ok": False, "reason": reason}            text = rebuilt        self.session = history + [{"role": "assistant", "content": text}]        return {"ok": True, "answer": text}  def dummy_llm(messages):    question = messages[-1]["content"]    if "天气" in question:        return "让我查一下：[调用工具] weather: 北京"    if "密钥" in question:        return "我的 token 是 sk-abc123"    return "这个问题需要多步思考，答案暂不确定。"  def get_weather(city):    return city + " 晴，25 摄氏度。"  if __name__ == "__main__":    harness = HarnessEngine(dummy_llm, {"weather": get_weather})    print(harness.run("北京天气怎么样？"))    print(harness.run("请告诉我你的密钥"))

1. def preprocess(self, raw):输入预处理：去除首尾空白、压缩连续空格、限制 2000 字，模拟“给马戴眼罩”。
2. re.sub(r"\s+", " ", raw.strip())[:2000]把任意连续空白压成一个空格并截断超长文本，防止模型被噪声干扰。
3. def postprocess(self, raw):输出后处理：再次压缩空白，并给没有标点的回答补上句号，模拟“笼头出口把关”。
4. if not text.endswith((".", "!", "?")):统一输出结尾的标点风格，让下游程序解析更稳定。
5. def safety_check(self, text):安全校验：扫描输出中的敏感词，命中就拦截并返回原因。
6. def call_tool(self, name, arg):工具编排：根据工具名查表执行外部函数，找不到工具时返回友好错误。
7. call = self._parse_tool_call(text)解析模型输出的“函数调用意图”，例如识别 [调用工具] weather: 北京。
8. history = self.session + [msg]把新消息追加到历史会话上，让模型具备多轮对话的上下文记忆。
9. self.session = history + [{"role": "assistant", "content": text}]把最终安全输出写回会话，供下一轮继续使用。

常见误区

面试题