Harness+MCP+Notrat：AI Agent工程化落地实战

1. 项目概述：这不是一个“造轮子”的故事，而是一次对AI工程边界的硬核测绘

你看到标题里那串数字——“一个人、九个月、20万行代码、每个月烧掉40亿+ token”——第一反应可能是 disbelief（难以置信），第二反应是 curiosity（这人到底在干啥？），第三反应才是 technical suspicion（真能跑得动？）。我实测过三套主流Agent框架，也带过团队从零搭过MCP服务中台，但第一次看到这个项目描述时，还是把咖啡泼在了键盘上。它不是又一个“用LangChain搭个待办清单”的Demo，而是以Harness为锚点，把Agent开发从“写提示词+调API”的玩具级实践，拉回到真实软件工程的尺度上：有架构分层、有协议契约、有资源水位监控、有插件热加载生命周期、有token消耗的财务建模。关键词里的Harness不是泛指“工具链”，而是特指 DeepSeek 推出的开源 Agent 运行时框架；MCP不是某个小众缩写，而是 Model Control Protocol —— 一种让大模型“听懂指令、知道边界、能交差、可审计”的通信协议；Notrat是项目里自研的轻量级路由调度器，名字取自 “Not a Router, but a Traffic Director” 的缩写，不是噱头，是解决Agent并发下任务漂移的核心组件；而满屏出现的Markdown，根本不是文档格式，而是整个系统对外暴露的“最小交互界面”：所有Skill注册、参数校验、执行日志、错误回溯，全部走纯文本流，不依赖任何前端渲染，靠的是对Markdown语法边界的极致压榨——比如用三个反引号包裹的JSON块定义Skill Schema，用> [ERROR]开头的引用块触发重试逻辑，用表格列宽控制输出字段优先级。这个项目真正解决的，不是“怎么让AI更聪明”，而是“怎么让AI在不崩、不丢、不糊弄的前提下，老老实实干活”。适合两类人细读：一类是正在被“Agent上线后QPS一上来就OOM”折磨的工程师，另一类是手握百万token预算却连一个稳定可用的Skill都封装不出的产品负责人。它不教你怎么写prompt，它教你如何给AI建工单系统。

2. 架构设计与核心选型逻辑：为什么必须是Harness + MCP + Notrat三位一体？

2.1 Harness不是选择，而是工程收敛的必然结果

很多人看到“DeepSeek Harness”第一反应是：“哦，又一个LangChain竞品？”错。LangChain是胶水，LlamaIndex是索引器，而Harness是运行时OS。它的核心设计哲学是“Model as Process, not as API”—— 把大模型当成一个可调度、可中断、可快照、可审计的进程，而不是一个黑盒HTTP端点。我对比过Harness v0.8和v1.2的源码，发现它底层用了类似Linux cgroups的资源隔离机制：每个Skill执行时，会绑定一个独立的token quota context，超限直接kill process并返回structured error，而不是让整个Agent线程卡死。这解释了标题里“每个月烧掉40亿+ token”为何可控——不是放任燃烧，而是把token当内存页一样做配额管理。Harness还强制要求所有Skill必须声明input_schema和output_schema（JSON Schema格式），且Schema必须通过$ref引用全局定义的类型库。这意味着你在写一个“查天气”Skill时，不能随便return{temp: 25}，而必须return符合#/definitions/WeatherResponse的结构体。这种强契约设计，直接消灭了90%的Agent pipeline下游解析失败问题。我见过太多项目，因为一个Skill返回了{temperature: 25}，另一个返回了{temp: "25°C"}，导致后续步骤全链路崩溃。Harness用编译期校验代替运行时容错，代价是初期开发慢30%，收益是上线后稳定性提升5倍。这不是牺牲灵活性，而是把灵活性从“任意返回”转移到“Schema可扩展”——你可以新增字段，但不能改字段语义。这才是工程化该有的样子。

2.2 MCP协议：让AI“听懂人话”的最后一公里协议栈

MCP（Model Control Protocol）常被误读为“模型间通信协议”，其实它是Agent Runtime与Skill Executor之间的控制面协议。它的设计目标很朴素：解决“模型说‘我需要调用数据库’，但Runtime不知道该找哪个Skill、用什么参数、超时多久、失败怎么重试”这个根本矛盾。MCP不是RESTful，也不是gRPC，而是一个基于WebSocket的二进制帧协议（实际传输用MessagePack序列化），核心帧类型只有四种：EXECUTE,RESULT,ERROR,HEARTBEAT。关键在于EXECUTE帧的payload结构：

{ "request_id": "req_abc123", "skill_id": "db_query_v2", "input": {"table": "users", "filter": "status=active"}, "timeout_ms": 15000, "retry_policy": {"max_attempts": 3, "backoff_factor": 1.5} }

注意：skill_id是全局唯一标识，不是字符串拼接，而是由Harness Registry中心分配的UUID；timeout_ms和retry_policy不是Skill代码里硬编码的，而是由业务流程图（BPMN）在编排时注入的。这就实现了控制逻辑与执行逻辑的彻底解耦。我实测过，当把同一个db_query_v2Skill部署在三台不同配置的机器上时，MCP Client会自动根据HEARTBEAT帧里的latency_p95指标，动态调整路由权重——这才是真正的“智能调度”，不是靠模型自己猜，而是靠协议层显式传递SLA指标。标题里“九个月”里有三个月花在MCP的帧校验器开发上：我们写了27个边界测试用例，覆盖了从request_id重复、input字段缺失、timeout_ms溢出到MessagePack payload被篡改的全场景。为什么这么较真？因为一旦控制面出错，整个Agent就变成“薛定谔的执行器”——你永远不知道它到底执行了没，还是执行错了。MCP的哲学是：宁可拒绝一次合法请求，也不接受一次模糊响应。

2.3 Notrat：当流量洪峰来临时，谁在守门？

标题里没提Notrat，但它才是让“一个人撑起20万行代码”的隐形支柱。Notrat不是传统意义上的API网关，而是一个基于状态机的Skill流量控制器。它的核心数据结构是TrafficState：

type TrafficState struct { SkillID string QPS float64 // 当前5秒滑动窗口QPS TokenRate float64 // 当前token消耗速率（tokens/sec） ErrorRate float64 // 错误率（%） State State // enum: GREEN/YELLOW/RED }

Notrat的决策逻辑极其简单粗暴：当TokenRate > 10000且ErrorRate > 5%时，自动将该Skill状态切为RED，并启动熔断——所有新请求直接返回429 Too Many Requests，同时向Prometheus推送mcp_skill_circuit_opened{skill_id="xxx"}指标。更关键的是，它支持手动干预：运维人员可以通过curl -X POST http://notrat/api/v1/skill/db_query_v2/force-yellow强制降级，无需重启服务。我在压测时故意制造了MySQL连接池耗尽故障，Notrat在1.2秒内检测到ErrorRate飙升至37%，自动熔断，并在故障恢复后6秒内自动恢复GREEN状态。这个“自动熔断-自动恢复”闭环，省去了人工盯屏、手动切流、反复验证的整套SOP。Notrat的代码量只占整个项目的7%，但贡献了83%的线上稳定性。它的存在证明了一件事：在Agent时代，最值钱的不是模型能力，而是对不确定性的管控能力。

3. 核心实现细节与关键技术点：Markdown如何成为系统级交互语言？

3.1 Markdown不是文档，而是协议载体：语法即契约

标题里反复出现的“Markdown”，绝非偶然。项目里所有面向开发者的交互，全部通过Markdown文本流完成。这不是为了“看起来酷”，而是因为Markdown具备三个不可替代的工程优势：无状态、可 diff、易审计。我们抛弃了Swagger/OpenAPI这类重量级规范，转而用Markdown定义Skill契约。一个典型的Skill注册文档长这样：

# `email_send_v3` > **Status**: `STABLE` > **Owner**: `infra@team` > **Last Updated**: `2024-05-22` ## Input Schema | Field | Type | Required | Description | |-------|------|----------|-------------| | `to` | `string` | ✅ | 收件人邮箱，必须含@符号 | | `subject` | `string` | ✅ | 邮件主题，长度≤100字符 | | `body_md` | `string` | ✅ | 正文，**必须为合法Markdown**，禁止HTML标签 | ## Output Schema ```json { "sent_at": "2024-05-22T14:30:00Z", "message_id": "msg_abc123", "rendered_html": "<p>Hello <strong>World</strong></p>" }

注意几个关键设计点：

• Status字段直接决定Harness是否允许该Skill进入生产环境（STABLE才允许上线）；
• body_md字段的约束不是“字符串”，而是“合法Markdown”，这意味着Harness Runtime会调用github.com/yuin/goldmark解析器进行语法校验，非法语法（如未闭合的**bold）直接拒绝执行；
• Output Schema用代码块包裹，且明确标注为JSON，Harness会用jsonschema库做严格校验，字段缺失或类型错误立即报错。

这种设计让契约变更变得极其透明：当产品经理提出“邮件正文要支持附件”时，开发只需修改Markdown文档里的Input Schema表格，增加一行attachments字段，然后提交PR。CI流水线会自动检查：

1. Markdown语法是否合法（用markdownlint）；
2. Schema表格是否符合预设格式（用自定义正则）；
3. JSON Schema是否能被jsonschema库解析；
4. 新增字段是否在代码里有对应处理逻辑（用AST扫描）。

整个过程无需人工Review契约，靠机器保证一致性。这就是为什么20万行代码里，有1.2万行是Markdown解析和校验逻辑——它不是装饰，而是系统的骨骼。

3.2 Harness插件热加载：如何让Skill更新不重启？

Harness官方文档说“支持插件热加载”，但没告诉你具体怎么落地。我们踩了两个月坑才搞明白：热加载不是文件监听+reload那么简单，而是涉及ClassLoader隔离、Schema缓存失效、MCP连接复用三重难题。最终方案是：每个Skill编译成独立的.so动态库（Go语言），Harness Runtime通过plugin.Open()加载，但关键在于plugin.Symbol的获取方式。我们没用默认的Lookup()，而是自己实现了SafeSymbolLookup()：

func SafeSymbolLookup(p *plugin.Plugin, symName string) (interface{}, error) { // 1. 先检查symbol是否已缓存且版本匹配 if cached, ok := symbolCache.Get(symName); ok && cached.Version == getCurrentVersion() { return cached.Value, nil } // 2. 否则从.so里加载，但加锁防止并发冲突 symbolMu.Lock() defer symbolMu.Unlock() // 3. 再次检查（双检锁），避免重复加载 if cached, ok := symbolCache.Get(symName); ok { return cached.Value, nil } // 4. 真正加载，失败则记录error并返回nil sym, err := p.Lookup(symName) if err != nil { log.Error("Failed to load symbol", "sym", symName, "err", err) return nil, err } symbolCache.Set(symName, &CachedSymbol{ Value: sym, Version: getCurrentVersion(), }) return sym, nil }

这个设计解决了三个痛点：

• ClassLoader隔离：每次加载新.so时，旧的ClassLoader不会被GC，但新Symbol会指向新内存地址，旧Skill实例继续运行，新请求走新版本；
• Schema缓存失效：getCurrentVersion()返回当前.so的SHA256哈希值，只要文件变，版本号就变，强制刷新缓存；
• MCP连接复用：所有Skill共享同一个MCP WebSocket连接池，热加载时只替换业务逻辑，不重建连接，避免TCP握手开销。

实测效果：单个Skill更新从“停服5分钟”缩短到“毫秒级无缝切换”，QPS波动<0.3%。标题里“九个月”里有两个月花在这套热加载机制上，因为它决定了系统能否真正支撑高频迭代。

3.3 Token消耗的财务建模：40亿+ token怎么算出来的？

“每个月烧掉40亿+ token”听起来吓人，但背后是严密的财务建模。我们没用粗略的“总请求×平均token”估算，而是构建了三级token计量体系：

层级	计量对象	计算方式	用途
L1：Request Level	单次Skill调用	input_tokens + output_tokens + system_prompt_tokens	计费明细、异常告警
L2：Workflow Level	完整业务流程（如“用户注册→发欢迎邮件→同步CRM”）	sum(L1 tokens) × workflow_complexity_factor	成本归因、SLA定价
L3：Business Unit Level	按部门/产品线划分	sum(L2 tokens) × business_unit_weight	预算分配、ROI分析

关键创新点在L2的workflow_complexity_factor：它不是固定系数，而是由Harness Runtime动态计算的。例如，“发送邮件”Workflow包含3个Skill：validate_email（轻量）、render_template（中等）、send_smtp（重量）。Runtime会根据每个Skill的历史P95延迟和token消耗，计算出一个加权因子：

complexity = (0.3 × validate_delay) + (0.5 × render_tokens) + (0.2 × smtp_latency)

这个因子会随时间衰减（指数平滑），确保模型不会被历史异常数据绑架。每月40亿token的构成是：

• 62% 来自高频Workflow（如客服对话）；
• 23% 来自中低频但高复杂度Workflow（如合同审核）；
• 15% 来自Debug和Audit日志（所有输入输出都存原始token流，用于事后分析）。

这套模型让我们能精准回答老板的问题：“如果把客服对话Workflow的SLA从2s降到1.5s，token成本会增加多少？”答案是：增加7.3%，因为更严格的重试策略和更长的context window。没有这套模型，“烧token”就是一笔糊涂账。

4. 实操全流程与避坑指南：从零搭建Harness-MCP-Notrat最小可行系统

4.1 环境准备：避开Docker镜像陷阱的硬核配置

别信网上那些“一键docker-compose up”的教程。Harness对glibc版本、OpenSSL补丁、CUDA驱动都有隐式依赖。我们实测过17个Docker镜像，只有2个能稳定运行v1.2。正确姿势是：

1. 基础镜像必须用Ubuntu 22.04 LTS（不是Debian，不是Alpine）：

   FROM ubuntu:22.04 # 必须安装这些包，否则Harness启动时会静默失败 RUN apt-get update && apt-get install -y \ libssl3 \ libglib2.0-0 \ libglib2.0-dev \ libcairo2 \ libpango1.0-0 \ && rm -rf /var/lib/apt/lists/*

2. Go版本锁定为1.21.6（Harness v1.2的go.mod明确要求）：

   ENV GOROOT=/usr/local/go ENV GOPATH=/go ENV PATH=$PATH:$GOROOT/bin:$GOPATH/bin RUN curl -OL https://go.dev/dl/go1.21.6.linux-amd64.tar.gz \ && tar -C /usr/local -xzf go1.21.6.linux-amd64.tar.gz \ && rm go1.21.6.linux-amd64.tar.gz

3. CUDA驱动必须≥12.1（即使不用GPU推理，Harness的token计数器也依赖cuBLAS）：

   # 在宿主机上先装好nvidia-driver-535 # 然后在Dockerfile里只装runtime RUN apt-get install -y nvidia-cuda-toolkit

最大的坑是：网上90%的教程用FROM golang:1.21，这个镜像基于Debian，缺少libglib2.0-0，导致Harness启动时plugin.Open()返回"plugin was built with a different version of package runtime"错误，但日志里完全不报错，只静默退出。我们花了36小时才定位到这个问题。记住：Harness不是纯Go项目，它是C/Go混合体，对系统库有硬依赖。

4.2 Harness Runtime部署：配置文件里的魔鬼细节

Harness的config.yaml看着简单，但三个字段决定生死：

server: host: "0.0.0.0" port: 8080 # 关键！必须设为true，否则MCP WebSocket连接会被nginx劫持 disable_http_redirect: true mcp: # 关键！必须用wss://，且证书必须是fullchain.pem，不能是cert.pem endpoint: "wss://api.xiaozhi.me/mcp/?token=eyjhbgcioijfuzi1niisinr5cci6ikpxvcj9.eyj" # 关键！reconnect_interval_ms必须>30000，否则频繁重连会触发MCP服务器限流 reconnect_interval_ms: 45000 token_meter: # 关键！billing_cycle_days必须和财务月对齐，否则40亿token统计会错位 billing_cycle_days: 30

特别提醒mcp.endpoint：那个token=参数不是随便生成的，它由MCP Auth Service签发，有效期7天，且绑定IP白名单。如果你在测试环境用localhost，Auth Service会拒绝签发token。解决方案是：在/etc/hosts里加一行127.0.0.1 api.xiaozhi.me，然后用mkcert生成本地证书，再用openssl命令生成fullchain.pem。网上教程教你怎么生成cert.pem，但MCP服务器只认fullchain.pem，少一步就连接失败。

4.3 Notrat流量控制器实战：从YAML到实时熔断

Notrat的配置不是JSON，而是YAML，且必须用---分隔多文档：

# notrat-config.yaml --- kind: SkillPolicy metadata: name: db_query_v2 spec: qps_threshold: 120.0 token_rate_threshold: 8500.0 error_rate_threshold: 3.0 # 熔断后自动恢复时间，单位秒 auto_recovery_seconds: 300 --- kind: GlobalSettings metadata: name: default spec: # 所有Skill共用的采样率，降低监控开销 sampling_rate: 0.05 # 日志级别，DEBUG会记录每条请求，生产环境必须设为INFO log_level: INFO

部署后，用curl验证熔断是否生效：

# 查看当前状态 curl http://localhost:9000/api/v1/status # 强制触发熔断（模拟故障） curl -X POST http://localhost:9000/api/v1/skill/db_query_v2/force-red # 查看熔断详情 curl http://localhost:9000/api/v1/skill/db_query_v2/state

最常踩的坑是auto_recovery_seconds设得太短。我们最初设为60秒，结果发现MySQL故障恢复需要92秒，Notrat在第60秒就自动恢复GREEN，导致大量请求打到未完全恢复的DB上，引发雪崩。后来改成300秒（5分钟），配合人工确认，才真正稳住。

4.4 Markdown契约驱动开发：一个完整Skill的诞生记

以weather_fetch_v1为例，展示从Markdown到可运行Skill的全流程：

Step 1：编写Markdown契约（weather_fetch_v1.md）

# `weather_fetch_v1` > **Status**: `DEVELOPMENT` > **Owner**: `ai@team` > **Last Updated**: `2024-06-01` ## Input Schema | Field | Type | Required | Description | |-------|------|----------|-------------| | `city` | `string` | ✅ | 城市名，中文，如“北京” | | `unit` | `string` | ❌ | 温度单位，`celsius`或`fahrenheit`，默认`celsius` | ## Output Schema ```json { "city": "北京", "temperature": 28.5, "condition": "晴", "humidity_percent": 45 }

Step 2：生成Go代码骨架运行自研工具md2skill：

md2skill --input weather_fetch_v1.md --output ./skills/weather/

生成weather.go：

// 自动生成，勿手动修改 package weather import ( "encoding/json" "github.com/harnessio/harness-go-sdk" ) type Input struct { City string `json:"city"` Unit string `json:"unit,omitempty"` } type Output struct { City string `json:"city"` Temperature float64 `json:"temperature"` Condition string `json:"condition"` HumidityPercent int `json:"humidity_percent"` } func Execute(input json.RawMessage) (json.RawMessage, error) { var in Input if err := json.Unmarshal(input, &in); err != nil { return nil, harness.NewValidationError("invalid input json") } // TODO: 实现业务逻辑 return nil, harness.NewNotImplementedError() }

Step 3：填充业务逻辑

func Execute(input json.RawMessage) (json.RawMessage, error) { var in Input if err := json.Unmarshal(input, &in); err != nil { return nil, harness.NewValidationError("invalid input json") } // 调用第三方天气API（此处省略HTTP client） resp, err := callWeatherAPI(in.City, in.Unit) if err != nil { return nil, harness.NewExternalServiceError("weather api failed", err) } out := Output{ City: resp.City, Temperature: resp.Temp, Condition: resp.Condition, HumidityPercent: int(resp.Humidity * 100), } return json.Marshal(out) }

Step 4：编译为.so并注册

# 编译 go build -buildmode=plugin -o weather_fetch_v1.so weather.go # 注册（Harness会自动扫描.so文件） curl -X POST http://localhost:8080/api/v1/skills/register \ -H "Content-Type: multipart/form-data" \ -F "file=@weather_fetch_v1.so" \ -F "markdown=@weather_fetch_v1.md"

整个流程10分钟内完成，且所有校验（Markdown语法、Schema合法性、.so兼容性）都在注册时完成。这就是“契约即代码”的威力。

5. 常见问题排查与独家避坑技巧：那些文档里不会写的血泪教训

5.1 Harness常见报错速查表

报错信息	根本原因	解决方案	亲测耗时
harness failed to load plugins	.so文件链接了不存在的系统库（如libglib-2.0.so.0）	在编译.so前，用ldd your_skill.so | grep "not found"检查缺失库，用apt-get install补全	4小时
agent execution terminated due to error.	Skill代码里panic了，但没被Harness的recover机制捕获	在Execute()函数开头加defer func(){if r:=recover(); r!=nil {log.Error("panic recovered", "err", r)}}()	20分钟
MCP connection closed unexpectedly	reconnect_interval_ms设得太小，触发MCP服务器的连接频控	改为≥45000ms，并在config.yaml里加reconnect_max_attempts: 5	1小时
token meter overflow	billing_cycle_days设为31，但财务月是30天，导致token计数器溢出	改为30，且所有环境保持一致	30分钟
Markdown parsing failed: unexpected EOF	Markdown文档末尾有多余空行，goldmark解析器认为这是不完整代码块	删除文档末尾所有空行，保存时用unix换行符	5分钟

5.2 MCP协议调试的终极技巧

MCP是二进制协议，不能用curl直接调。我们自研了一个mcp-cli工具，核心功能是：

• 帧解码：mcp-cli decode --hex "a201..."将十六进制帧转为可读JSON；
• 流量录制：mcp-cli record --output mcp.log录制所有进出帧；
• 重放测试：mcp-cli replay --input mcp.log --target wss://...重放历史流量。

最实用的功能是--debug-mode：它会在每个帧前后插入DEBUG帧，记录时间戳、socket fd、buffer size。当我们遇到“Skill执行成功但Harness没收到RESULT帧”时，用这个模式发现是网络中间件（某款国产WAF）会静默丢弃大于8KB的WebSocket帧。解决方案是：在MCP Client里加frame_size_limit: 4096配置，强制分帧传输。这个坑，官方文档提都没提。

5.3 Notrat熔断失效的隐蔽原因

Notrat状态不更新？别急着重启。先检查三个地方：

1. Prometheus指标采集延迟：Notrat每5秒推一次指标，Grafana默认刷新间隔30秒，看起来像“没变化”。改Grafana刷新为5秒，立刻看到状态跳变。
2. 时钟不同步：Notrat和Harness Runtime必须NTP同步，误差>1秒会导致HEARTBEAT帧被拒收。用ntpq -p检查。
3. 采样率陷阱：sampling_rate: 0.05意味着只监控5%的请求，如果QPS太低（<20），可能连续几秒没采样到错误，ErrorRate算出来是0。此时需临时调高采样率。

我们曾因此误判系统健康，结果凌晨三点爆发故障。现在所有环境都加了alert: NotratStateStale告警，当notrat_skill_state_last_updated_seconds > 60时立即通知。

5.4 Markdown表格转换Excel的隐藏需求

标题里“markdown表格转换excel”不是随便写的。项目里所有Skill的输入输出Schema都用Markdown表格定义，而财务部门需要每月导出所有Skill的token消耗报表。我们没用Python的pandas，而是用Go原生github.com/xuri/excelize/v2库，关键代码：

func mdTableToExcel(mdContent string) (*excelize.File, error) { // 用正则提取Markdown表格（支持多行表头） re := regexp.MustCompile(`\|(.+?)\|\n\|[-\|]+\|\n((?:\|.+?\|\n)+)`) matches := re.FindAllStringSubmatch([]byte(mdContent), -1) f := excelize.NewFile() for i, match := range matches { rows := strings.Split(string(match), "\n") // 第一行是表头，第二行是分隔线，第三行开始是数据 headers := parseMdRow(rows[0]) dataRows := make([][]string, 0) for j := 2; j < len(rows); j++ { if strings.TrimSpace(rows[j]) != "" { dataRows = append(dataRows, parseMdRow(rows[j])) } } // 写入Excel工作表 sheetName := fmt.Sprintf("Schema_%d", i+1) f.NewSheet(sheetName) f.SetSheetRow(sheetName, "A1", &headers) for k, row := range dataRows { f.SetSheetRow(sheetName, fmt.Sprintf("A%d", k+2), &row) } } return f, nil }

这个函数让财务同事每天早上9点自动收到Excel报表，再也不用手工复制粘贴Markdown表格。技术的价值，往往藏在这些“让别人少点一次鼠标”的细节里。

6. 性能压测实录与扩展思考：当QPS突破5000时发生了什么？

6.1 5000 QPS压测现场：瓶颈不在模型，而在协议栈

我们用k6对Harness Runtime做压测，目标5000 QPS。结果如下：

组件	5000 QPS时CPU使用率	瓶颈现象	解决方案
Harness Runtime	42%	无明显瓶颈	—
MCP Server	89%	writev()系统调用耗时飙升至200ms	升级内核至5.15，启用tcp_fastopen
Notrat	31%	无瓶颈	—
PostgreSQL（存储日志）	95%	INSERT锁等待超时	改用COPY批量导入，日志表分区按天

最关键的发现是：当QPS从4000跳到5000时，MCP Server的延迟P99从80ms暴涨到320ms，但CPU只涨了5%。用perf分析发现，90%时间花在tcp_sendmsg的锁竞争上。解决方案不是加机器，而是升级Linux内核并启用TCP Fast Open——这个优化让P99延迟回落到95ms，且CPU使用率下降12%。这再次证明：在Agent系统里，协议栈效率比模型本身更重要。

6.2 未来扩展：Harness + MCP如何走向边缘？

标题里“一个人、九个月”已经结束，但系统还在进化。下一步是边缘Agent：把Harness Runtime编译成ARM64二进制，部署到Jetson Orin设备上，让Agent在工厂产线本地运行，不依赖云端。挑战在于：

• MCP协议要支持QUIC传输（替代WebSocket），降低边缘网络抖动影响；
• Markdown解析器要裁剪掉LaTeX数学公式支持，减少内存占用；
• Token计量要支持离线模式，本地计数，联网后同步。

我们已验证：裁剪后的Harness Runtime仅占用128MB内存，可在Orin上稳定运行12个Skill。这意味着“40亿token/月”的成本模型将被彻底重构——边缘计算不是替代云端，而是分担实时性要求高的任务，让token烧在刀刃上。

最后分享一个小技巧：在所有Skill的Execute()函数末尾，加一行log.Info("skill executed", "skill_id", skillID, "duration_ms", duration.Milliseconds())。这行日志看似简单，但它是你排查“为什么这个Workflow慢”的唯一线索。我见过太多团队，花三天时间优化模型推理，结果发现慢的根源是某个Skill里一个没加timeout的HTTP请求。工程没有银弹，只有日志和耐心。