Cygnus Tech Blog
Cygnus Tech Blog

第06章 Claude Code Harness 架构剖析 —— 编程 Agent 的标杆实现

Cygnus Yang 收录于 01-AI 工具与智能体/07-Harness
 约 1900 字 预计阅读 9 分钟 

上一篇我们辨析了 Model、Agent、Harness 三者的关系。本章我们深入剖析 Claude Code——Harness 工程的标杆实现。

Claude Code 是什么

一句话定义：Anthropic 官方的编程 Agent——Claude 模型 + IDE/终端 Harness，专为软件工程设计。

Claude Code = Claude 模型（推理）+ 编程 Harness（行动） 定位：编程 Agent，理解代码库、编写代码、调试错误、完成开发任务

核心能力：

  • ✅ 理解代码库（Glob、Grep、Read）
  • ✅ 编写代码（Write、Edit）
  • ✅ 执行命令（Bash、npm、git）
  • ✅ 调试错误（分析日志、修复代码）
  • ✅ 团队协作（子 Agent、任务系统）

Claude Code 的 Harness 架构

四层架构总览

图表 代码
graph TB
    subgraph ClaudeCode["Claude Code Harness"]
        subgraph L4["扩展层"]
            E1[Skills 按需加载]
            E2[MCP 插件集成]
            E3[Hooks 扩展点]
        end
        
        subgraph L3["管理层"]
            M1[Permissions
deny→ask→allow]
            M2[Context 压缩
四层策略]
            M3[任务系统
TodoWrite]
            M4[子 Agent 派发
Agent 工具]
        end
        
        subgraph L2["工具层"]
            T1[Bash
命令执行]
            T2[Read/Write/Edit
文件操作]
            T3[Glob/Grep
搜索导航]
            T4[Browser/MCP
网络/外部]
        end
        
        subgraph L1["Loop层"]
            LOOP[Agent Loop
observe→think→act→feedback]
        end
        
        L4 --> L3 --> L2 --> L1
    end
    
    Model[Claude 4.x
推理引擎] -->|调用| ClaudeCode
    ClaudeCode -->|执行| Env[IDE/终端/文件系统]
graph TB
    subgraph ClaudeCode["Claude Code Harness"]
        subgraph L4["扩展层"]
            E1[Skills 按需加载]
            E2[MCP 插件集成]
            E3[Hooks 扩展点]
        end
        
        subgraph L3["管理层"]
            M1[Permissions
deny→ask→allow]
            M2[Context 压缩
四层策略]
            M3[任务系统
TodoWrite]
            M4[子 Agent 派发
Agent 工具]
        end
        
        subgraph L2["工具层"]
            T1[Bash
命令执行]
            T2[Read/Write/Edit
文件操作]
            T3[Glob/Grep
搜索导航]
            T4[Browser/MCP
网络/外部]
        end
        
        subgraph L1["Loop层"]
            LOOP[Agent Loop
observe→think→act→feedback]
        end
        
        L4 --> L3 --> L2 --> L1
    end
    
    Model[Claude 4.x
推理引擎] -->|调用| ClaudeCode
    ClaudeCode -->|执行| Env[IDE/终端/文件系统]
graph TB
    subgraph ClaudeCode["Claude Code Harness"]
        subgraph L4["扩展层"]
            E1[Skills 按需加载]
            E2[MCP 插件集成]
            E3[Hooks 扩展点]
        end
        
        subgraph L3["管理层"]
            M1[Permissions
deny→ask→allow]
            M2[Context 压缩
四层策略]
            M3[任务系统
TodoWrite]
            M4[子 Agent 派发
Agent 工具]
        end
        
        subgraph L2["工具层"]
            T1[Bash
命令执行]
            T2[Read/Write/Edit
文件操作]
            T3[Glob/Grep
搜索导航]
            T4[Browser/MCP
网络/外部]
        end
        
        subgraph L1["Loop层"]
            LOOP[Agent Loop
observe→think→act→feedback]
        end
        
        L4 --> L3 --> L2 --> L1
    end
    
    Model[Claude 4.x
推理引擎] -->|调用| ClaudeCode
    ClaudeCode -->|执行| Env[IDE/终端/文件系统]
graph TB
    subgraph ClaudeCode["Claude Code Harness"]
        subgraph L4["扩展层"]
            E1[Skills 按需加载]
            E2[MCP 插件集成]
            E3[Hooks 扩展点]
        end
        
        subgraph L3["管理层"]
            M1[Permissions<br/>deny→ask→allow]
            M2[Context 压缩<br/>四层策略]
            M3[任务系统<br/>TodoWrite]
            M4[子 Agent 派发<br/>Agent 工具]
        end
        
        subgraph L2["工具层"]
            T1[Bash<br/>命令执行]
            T2[Read/Write/Edit<br/>文件操作]
            T3[Glob/Grep<br/>搜索导航]
            T4[Browser/MCP<br/>网络/外部]
        end
        
        subgraph L1["Loop层"]
            LOOP[Agent Loop<br/>observe→think→act→feedback]
        end
        
        L4 --> L3 --> L2 --> L1
    end
    
    Model[Claude 4.x<br/>推理引擎] -->|调用| ClaudeCode
    ClaudeCode -->|执行| Env[IDE/终端/文件系统]

核心公式 

Claude Code = Agent Loop（心跳）
            + Tools（双手：Bash/Read/Write/Edit/Glob/Grep/Browser）
            + Skills 按需加载（脑库：CLAUDE.md + Skills 文件夹）
            + Context 压缩（记忆：四层压缩策略）
            + Permissions（边界：deny→ask→allow）
            + 子 Agent 派发（团队：Agent 工具）
            + MCP 扩展（外挂：自定义 MCP 服务器）
            + Hooks（拦截：PreToolUse/PostToolUse/Stop）

第一层：Agent Loop —— Claude Code 的心跳

Loop 的核心机制

图表 代码
flowchart LR
    A[messages 数组
对话历史 + 工具输出] --> B[Claude 4.x
推理引擎]
    B --> C{stop_reason
判断}
    C -->|tool_use| D[执行工具
Bash/Read/Write/Edit]
    D --> E[收集结果
工具输出 + 错误信息]
    E -->|append| A
    C -->|end_turn| F[返回用户
最终回答]
flowchart LR
    A[messages 数组
对话历史 + 工具输出] --> B[Claude 4.x
推理引擎]
    B --> C{stop_reason
判断}
    C -->|tool_use| D[执行工具
Bash/Read/Write/Edit]
    D --> E[收集结果
工具输出 + 错误信息]
    E -->|append| A
    C -->|end_turn| F[返回用户
最终回答]
flowchart LR
    A[messages 数组
对话历史 + 工具输出] --> B[Claude 4.x
推理引擎]
    B --> C{stop_reason
判断}
    C -->|tool_use| D[执行工具
Bash/Read/Write/Edit]
    D --> E[收集结果
工具输出 + 错误信息]
    E -->|append| A
    C -->|end_turn| F[返回用户
最终回答]
flowchart LR
    A[messages 数组<br/>对话历史 + 工具输出] --> B[Claude 4.x<br/>推理引擎]
    B --> C{stop_reason<br/>判断}
    C -->|tool_use| D[执行工具<br/>Bash/Read/Write/Edit]
    D --> E[收集结果<br/>工具输出 + 错误信息]
    E -->|append| A
    C -->|end_turn| F[返回用户<br/>最终回答]

关键机制：

  • messages 数组：存储完整对话历史（用户消息 + Model 响应 + 工具输出）
  • stop_reason 判断：Model 决定继续循环（tool_use）还是结束对话（end_turn）
  • 工具分发：根据 Model 的 tool_use 决策，执行对应工具

Loop 的格言

“One loop & Bash is all you need” —— 一个工具 + 一个循环 = 一个 Agent

最小 Agent Loop：

# 伪代码：Claude Code 的最小 Agent Loop
messages = [{"role": "user", "content": user_input}]

while True:
    response = claude.chat(messages)
    
    if response.stop_reason == "end_turn":
        return response.content  # 返回最终结果
    
    if response.stop_reason == "tool_use":
        tool_name = response.tool_name
        tool_args = response.tool_args
        
        # 权限检查（管理层插入）
        permission = check_permission(tool_name, tool_args)
        if permission == "deny":
            tool_result = "Error: Operation denied"
        elif permission == "ask":
            tool_result = ask_user_confirmation(tool_name, tool_args)
        else:  # allow
            tool_result = execute_tool(tool_name, tool_args)
        
        # 追加到 messages 数组
        messages.append({"role": "assistant", "content": response})
        messages.append({"role": "user", "content": tool_result})

第二层：工具系统 —— Claude Code 的双手

核心工具一览

工具类别工具名称功能参数示例
命令执行Bash执行 Shell 命令command: "npm install"
文件操作Read读取文件内容file_path: "/src/app.ts"
文件操作Write写入新文件file_path, content
文件操作Edit编辑文件片段file_path, old_string, new_string
搜索导航Glob搜索文件路径pattern: "**/*.ts"
搜索导航Grep搜索文件内容pattern: "function_name"
网络交互WebFetch网络请求url: "https://..."
网络交互WebSearch网络搜索query: "React hooks"
浏览器Browser_navigate打开网页url: "https://..."
浏览器Browser_click点击元素ref: "element_ref"
子 AgentAgent派发子任务prompt, subagent_type

工具设计原则

格言：

“加一个工具, 只加一个 handler” —— 循环不用动，新工具注册进 dispatch map 就行

原子化 + 可组合：

图表 代码
graph LR
    G[Glob
搜索文件] --> R[Read
读取内容]
    R --> E[Edit
编辑片段]
    E --> B[Bash
运行测试]
    
    G[找到 test/*.ts] --> R[读取测试文件]
    R --> E[修改测试代码]
    E --> B[npm test]
graph LR
    G[Glob
搜索文件] --> R[Read
读取内容]
    R --> E[Edit
编辑片段]
    E --> B[Bash
运行测试]
    
    G[找到 test/*.ts] --> R[读取测试文件]
    R --> E[修改测试代码]
    E --> B[npm test]
graph LR
    G[Glob
搜索文件] --> R[Read
读取内容]
    R --> E[Edit
编辑片段]
    E --> B[Bash
运行测试]
    
    G[找到 test/*.ts] --> R[读取测试文件]
    R --> E[修改测试代码]
    E --> B[npm test]
graph LR
    G[Glob<br/>搜索文件] --> R[Read<br/>读取内容]
    R --> E[Edit<br/>编辑片段]
    E --> B[Bash<br/>运行测试]
    
    G[找到 test/*.ts] --> R[读取测试文件]
    R --> E[修改测试代码]
    E --> B[npm test]

工具分发机制：

图表 代码
sequenceDiagram
    participant Loop as Agent Loop
    participant Perm as 权限系统
    participant Registry as 工具注册表
    participant Exec as 工具执行器
    participant Hooks as Hooks 系统
    
    Loop->>Perm: 检查权限
    Perm-->>Loop: 返回 permission 结果
    
    Loop->>Registry: 查询工具定义
    Registry-->>Loop: 返回工具 schema
    
    Loop->>Hooks: PreToolUse Hook
    Hooks-->>Loop: Hook 处理完成
    
    Loop->>Exec: 执行工具
    Exec-->>Loop: 返回结果
    
    Loop->>Hooks: PostToolUse Hook
    Hooks-->>Loop: Hook 处理完成
sequenceDiagram
    participant Loop as Agent Loop
    participant Perm as 权限系统
    participant Registry as 工具注册表
    participant Exec as 工具执行器
    participant Hooks as Hooks 系统
    
    Loop->>Perm: 检查权限
    Perm-->>Loop: 返回 permission 结果
    
    Loop->>Registry: 查询工具定义
    Registry-->>Loop: 返回工具 schema
    
    Loop->>Hooks: PreToolUse Hook
    Hooks-->>Loop: Hook 处理完成
    
    Loop->>Exec: 执行工具
    Exec-->>Loop: 返回结果
    
    Loop->>Hooks: PostToolUse Hook
    Hooks-->>Loop: Hook 处理完成
sequenceDiagram
    participant Loop as Agent Loop
    participant Perm as 权限系统
    participant Registry as 工具注册表
    participant Exec as 工具执行器
    participant Hooks as Hooks 系统
    
    Loop->>Perm: 检查权限
    Perm-->>Loop: 返回 permission 结果
    
    Loop->>Registry: 查询工具定义
    Registry-->>Loop: 返回工具 schema
    
    Loop->>Hooks: PreToolUse Hook
    Hooks-->>Loop: Hook 处理完成
    
    Loop->>Exec: 执行工具
    Exec-->>Loop: 返回结果
    
    Loop->>Hooks: PostToolUse Hook
    Hooks-->>Loop: Hook 处理完成
sequenceDiagram
    participant Loop as Agent Loop
    participant Perm as 权限系统
    participant Registry as 工具注册表
    participant Exec as 工具执行器
    participant Hooks as Hooks 系统
    
    Loop->>Perm: 检查权限
    Perm-->>Loop: 返回 permission 结果
    
    Loop->>Registry: 查询工具定义
    Registry-->>Loop: 返回工具 schema
    
    Loop->>Hooks: PreToolUse Hook
    Hooks-->>Loop: Hook 处理完成
    
    Loop->>Exec: 执行工具
    Exec-->>Loop: 返回结果
    
    Loop->>Hooks: PostToolUse Hook
    Hooks-->>Loop: Hook 处理完成

第三层：管理层 —— Claude Code 的辅助系统

1. Permissions 权限系统

格言：

“先划边界, 再给自由” —— 先判断操作能不能做，要不要问用户

权限模式：

模式行为适用工具示例
deny❌ 禁止执行危险操作删除系统文件、访问密钥
ask⚠️ 请求审批中等风险git push、npm install、rm -rf
allow✅ 自动执行安全操作Read、Glob、Grep

权限流程：

图表 代码
graph LR
    A[工具调用] --> B{权限规则匹配}
    B -->|deny 规则| C[❌ 禁止
返回错误]
    B -->|ask 规则| D[⚠️ 请求审批
等待用户确认]
    B -->|allow 规则| E[✅ 自动执行]
    B -->|无匹配| F[默认 ask]
graph LR
    A[工具调用] --> B{权限规则匹配}
    B -->|deny 规则| C[❌ 禁止
返回错误]
    B -->|ask 规则| D[⚠️ 请求审批
等待用户确认]
    B -->|allow 规则| E[✅ 自动执行]
    B -->|无匹配| F[默认 ask]
graph LR
    A[工具调用] --> B{权限规则匹配}
    B -->|deny 规则| C[❌ 禁止
返回错误]
    B -->|ask 规则| D[⚠️ 请求审批
等待用户确认]
    B -->|allow 规则| E[✅ 自动执行]
    B -->|无匹配| F[默认 ask]
graph LR
    A[工具调用] --> B{权限规则匹配}
    B -->|deny 规则| C[❌ 禁止<br/>返回错误]
    B -->|ask 规则| D[⚠️ 请求审批<br/>等待用户确认]
    B -->|allow 规则| E[✅ 自动执行]
    B -->|无匹配| F[默认 ask]

2. Context 压缩

格言：

“上下文总会满, 要有办法腾地方” —— 四层压缩策略，便宜的先跑贵的后跑

四层压缩策略：

层级方法成本效果
Layer 1滚动窗口（保留最近 N 条）低减少 50%
Layer 2重要性过滤（保留关键决策）中减少 70%
Layer 3摘要压缩（历史摘要为段落）高减少 90%
Layer 4子 Agent 隔离（不泄露上下文）最高防止污染

触发时机：

  • messages 数组接近上下文窗口上限（Claude 4.x 约 200K tokens）
  • 用户手动触发压缩（/compact 命令）
  • 子 Agent 派发时自动隔离

3. 任务系统 TodoWrite

格言：

“没有计划的 agent 走哪算哪” —— 先列步骤再动手，完成率翻倍

任务状态：

状态含义Model 行为
pending等待执行初始化任务
in_progress正在执行开始工作
completed执行完成标记完成
blocked被阻塞等待依赖

任务依赖：

图表 代码
graph LR
    T1[任务1
创建目录] --> T2[任务2
克隆仓库]
    T2 --> T3[任务3
安装依赖]
    T3 --> T4[任务4
启动服务]
    
    T2[blockedBy: T1]
    T3[blockedBy: T2]
    T4[blockedBy: T3]
graph LR
    T1[任务1
创建目录] --> T2[任务2
克隆仓库]
    T2 --> T3[任务3
安装依赖]
    T3 --> T4[任务4
启动服务]
    
    T2[blockedBy: T1]
    T3[blockedBy: T2]
    T4[blockedBy: T3]
graph LR
    T1[任务1
创建目录] --> T2[任务2
克隆仓库]
    T2 --> T3[任务3
安装依赖]
    T3 --> T4[任务4
启动服务]
    
    T2[blockedBy: T1]
    T3[blockedBy: T2]
    T4[blockedBy: T3]
graph LR
    T1[任务1<br/>创建目录] --> T2[任务2<br/>克隆仓库]
    T2 --> T3[任务3<br/>安装依赖]
    T3 --> T4[任务4<br/>启动服务]
    
    T2[blockedBy: T1]
    T3[blockedBy: T2]
    T4[blockedBy: T3]

4. 子 Agent 派发

格言：

“大任务拆小, 每个小任务干净的上下文” —— 子 Agent 自己干活，只把结果带回来

子 Agent 隔离机制：

图表 代码
graph TB
    Main[主 Agent
messages 数组A
主上下文]
    
    Main -->|派发
Agent(prompt)| Sub1[子 Agent 1
messages 数组B
隔离上下文]
    Main -->|派发| Sub2[子 Agent 2
messages 数组C
隔离上下文]
    
    Sub1 -->|返回结果
不泄露历史| Main
    Sub2 -->|返回结果
不泄露历史| Main
    
    Sub1[上下文隔离
只返回最终结果]
    Sub2[上下文隔离
只返回最终结果]
graph TB
    Main[主 Agent
messages 数组A
主上下文]
    
    Main -->|派发
Agent(prompt)| Sub1[子 Agent 1
messages 数组B
隔离上下文]
    Main -->|派发| Sub2[子 Agent 2
messages 数组C
隔离上下文]
    
    Sub1 -->|返回结果
不泄露历史| Main
    Sub2 -->|返回结果
不泄露历史| Main
    
    Sub1[上下文隔离
只返回最终结果]
    Sub2[上下文隔离
只返回最终结果]
graph TB
    Main[主 Agent
messages 数组A
主上下文]
    
    Main -->|派发
Agent(prompt)| Sub1[子 Agent 1
messages 数组B
隔离上下文]
    Main -->|派发| Sub2[子 Agent 2
messages 数组C
隔离上下文]
    
    Sub1 -->|返回结果
不泄露历史| Main
    Sub2 -->|返回结果
不泄露历史| Main
    
    Sub1[上下文隔离
只返回最终结果]
    Sub2[上下文隔离
只返回最终结果]
graph TB
    Main[主 Agent<br/>messages 数组A<br/>主上下文]
    
    Main -->|派发<br/>Agent(prompt)| Sub1[子 Agent 1<br/>messages 数组B<br/>隔离上下文]
    Main -->|派发| Sub2[子 Agent 2<br/>messages 数组C<br/>隔离上下文]
    
    Sub1 -->|返回结果<br/>不泄露历史| Main
    Sub2 -->|返回结果<br/>不泄露历史| Main
    
    Sub1[上下文隔离<br/>只返回最终结果]
    Sub2[上下文隔离<br/>只返回最终结果]

子 Agent 类型：

子 Agent 类型用途特点
Explore快速探索代码库搜索文件、查找代码
Plan规划实施方案设计架构、制定步骤
Review代码审查检查质量、安全漏洞
General-purpose通用任务多步骤复杂任务

第四层：扩展层 —— Claude Code 的外挂系统

1. Skills 按需加载

格言：

“用到时再加载, 别全塞 prompt 里” —— 技能先列目录，用到时再展开

Skills 来源：

Skills 类型内容加载方式
CLAUDE.md项目约定、架构、注意事项自动注入上下文
skills/*.md技术知识、领域文档Model 判断需要时加载
规则文件编码规范、测试要求自动注入

加载流程：

图表 代码
graph LR
    Model[Claude 推理] -->|判断需要
领域知识| K[查询 Skills 列表]
    K -->|读取| S[Skills Markdown]
    S -->|注入| C[上下文 messages]
    C -->|增强推理| Model
graph LR
    Model[Claude 推理] -->|判断需要
领域知识| K[查询 Skills 列表]
    K -->|读取| S[Skills Markdown]
    S -->|注入| C[上下文 messages]
    C -->|增强推理| Model
graph LR
    Model[Claude 推理] -->|判断需要
领域知识| K[查询 Skills 列表]
    K -->|读取| S[Skills Markdown]
    S -->|注入| C[上下文 messages]
    C -->|增强推理| Model
graph LR
    Model[Claude 推理] -->|判断需要<br/>领域知识| K[查询 Skills 列表]
    K -->|读取| S[Skills Markdown]
    S -->|注入| C[上下文 messages]
    C -->|增强推理| Model

2. MCP 插件集成

MCP 定义：Model Context Protocol——连接 AI 和外部系统的开放协议。

Claude Code 的 MCP 支持：

MCP 服务器功能提供的工具
filesystem文件系统操作read_file、write_file
database数据库连接query、insert、update
web网络访问fetch、search
custom自定义系统企业 API、云服务

3. Hooks 扩展点

格言：

“挂在循环上, 不写进循环里” —— 在工具前后留插口，不改主循环也能扩展

Hooks 类型：

Hook 类型触发时机用途
PreToolUse工具执行前参数验证、权限增强
PostToolUse工具执行后自动格式化、结果处理
Stop会话结束时最终验证、清理工作

示例配置：

// PostToolUse Hook 示例
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",  // 写入文件后
        "hooks": ["npm run format"]  // 自动格式化
      }
    ]
  }
}

Claude Code 的设计哲学

为什么 Claude Code 成功

核心哲学：信任 Model，专注 Harness。

维度Claude Code 的做法提示词水管工的做法
工作流❌ 不强加僵化工作流✅ 硬编码节点图
决策❌ 让 Model 自主决策✅ if-else 路由
工具✅ 提供丰富工具❌ 固定调用顺序
知识✅ 按需加载 Skills❌ 预定义知识库
权限✅ deny→ask→allow❌ 无权限系统
图表 代码
graph TB
    subgraph ClaudeCode["Claude Code (真Agent)"]
        C1[Model 自主决策]
        C2[工具丰富可组合]
        C3[Skills 按需加载]
        C4[权限边界清晰]
        C5[上下文智能管理]
    end
    
    subgraph WaterPlumber["提示词水管工 (假Agent)"]
        W1[硬编码工作流]
        W2[固定调用顺序]
        W3[预定义知识库]
        W4[无权限系统]
        W5[无上下文管理]
    end
    
    style ClaudeCode fill:#E0FFE0
    style WaterPlumber fill:#FFE0E0
graph TB
    subgraph ClaudeCode["Claude Code (真Agent)"]
        C1[Model 自主决策]
        C2[工具丰富可组合]
        C3[Skills 按需加载]
        C4[权限边界清晰]
        C5[上下文智能管理]
    end
    
    subgraph WaterPlumber["提示词水管工 (假Agent)"]
        W1[硬编码工作流]
        W2[固定调用顺序]
        W3[预定义知识库]
        W4[无权限系统]
        W5[无上下文管理]
    end
    
    style ClaudeCode fill:#E0FFE0
    style WaterPlumber fill:#FFE0E0
graph TB
    subgraph ClaudeCode["Claude Code (真Agent)"]
        C1[Model 自主决策]
        C2[工具丰富可组合]
        C3[Skills 按需加载]
        C4[权限边界清晰]
        C5[上下文智能管理]
    end
    
    subgraph WaterPlumber["提示词水管工 (假Agent)"]
        W1[硬编码工作流]
        W2[固定调用顺序]
        W3[预定义知识库]
        W4[无权限系统]
        W5[无上下文管理]
    end
    
    style ClaudeCode fill:#E0FFE0
    style WaterPlumber fill:#FFE0E0
graph TB
    subgraph ClaudeCode["Claude Code (真Agent)"]
        C1[Model 自主决策]
        C2[工具丰富可组合]
        C3[Skills 按需加载]
        C4[权限边界清晰]
        C5[上下文智能管理]
    end
    
    subgraph WaterPlumber["提示词水管工 (假Agent)"]
        W1[硬编码工作流]
        W2[固定调用顺序]
        W3[预定义知识库]
        W4[无权限系统]
        W5[无上下文管理]
    end
    
    style ClaudeCode fill:#E0FFE0
    style WaterPlumber fill:#FFE0E0

Claude Code 的启示

最好的 Agent 产品，出自那些明白自己的工作是 Harness 而非 Intelligence 的工程师之手。

关键启示：

  1. Agency 来自 Model：推理能力是 Claude 在训练中学到的，不是代码编排的
  2. Harness 提供环境：工具、权限、上下文、知识——让 Model 能干活
  3. 信任 Model：不强加工作流，让 Model 自主决策下一步
  4. 专注边界：权限系统保护安全，上下文管理防止溢出

Claude Code vs 其他编程 Agent

维度Claude CodeCursorWindsurfCodex CLI
ModelClaude 4.xClaude/GPT-4ClaudeGPT-4
Loop✅ Agent Loop✅ Agent Loop✅ Agent Loop✅ Agent Loop
工具数量20+10+15+5+
Skills✅ 按需加载❌ 固定知识✅ 项目知识❌ 无
MCP✅ 完整支持❌ 无✅ 部分❌ 无
子 Agent✅ 多类型❌ 无✅ 单类型❌ 无
权限系统✅ 三级权限❌ 无✅ 基础❌ 无
上下文压缩✅ 四层策略✅ 基础✅ 基础❌ 无

本章小结

  • Claude Code 架构：Loop + Tools + Skills + Context + Permissions + SubAgent + MCP + Hooks
  • Loop层：observe→think→act→feedback 的持续循环
  • 工具层：Bash/Read/Write/Edit/Glob/Grep/Browser/Agent（20+ 工具）
  • 管理层：权限三级模式、上下文四层压缩、任务系统、子 Agent 派发
  • 扩展层：Skills 按需加载、MCP 插件、Hooks 扩展点
  • 设计哲学：信任 Model、专注 Harness、不强加工作流
  • 关键启示：最好的 Agent 出自专注 Harness 的工程师之手

预告：下一篇我们剖析 Codex CLI——OpenAI 的命令行 Agent 实现。

相关内容

收录于 合集・01-AI 工具与智能体/07-Harness 27
更新于 2026-05-23 
CC BY-NC-SA 4.0
返回 | 主页
如果这篇文章对你有帮助，欢迎请我喝杯咖啡 ☕
Cygnus Yang 支付宝支付宝
Cygnus Yang 微信微信

目录