AI Agent框架横向对比深度解析：DeepSeek Harness vs Claude Code vs Codex vs OpenCode全维度评测

2026年是AI Agent框架的爆发之年。从OpenAI的Codex到Anthropic的Claude Code，从开源的OpenCode到DeepSeek的Harness，四大阵营正在争夺Agent运行时的定义权。选择什么框架，不只是技术选型问题，更决定了企业Agent系统的扩展能力、安全边界和长期成本。本文从架构设计、插件体系、安全模型、多Agent能力、生态成熟度、性能表现和企业适配七个维度，对四大主流Agent框架进行全维度横向对比。

一、四大框架定位与起源

1.1 基本信息一览

框架	开发商	开源协议	首发时间	主要语言	核心定位
DeepSeek Harness (dsh)	DeepSeek AI	MIT	2026.08	TypeScript(97%)	开源Agent运行时框架
Claude Code	Anthropic	Proprietary	2025.10	TypeScript	Claude原生编程Agent
Codex (CLI)	OpenAI	MIT	2026.03	Rust	OpenAI原生代码Agent CLI
OpenCode	社区/OpenCode团队	Apache 2.0	2025.12	Go	开源通用Coding Agent

1.2 设计哲学差异

DeepSeek Harness:  Everything is a Plugin

  ↳ 整个系统就是一棵插件树，没有特权内核

  ↳ 模型、工具、循环、日志、UI全部可替换

Claude Code:  Best-in-Class Claude Experience

  ↳ 深度优化Claude模型的编程体验

  ↳ 工具、提示词、工作流围绕Claude设计

Codex:  Native OpenAI Agent CLI

  ↳ 展示OpenAI模型的编码能力

  ↳ 简洁高效的命令行工具

OpenCode:  Community-Driven Open Agent

  ↳ 社区驱动的开源替代方案

  ↳ 多模型支持，模块化设计

1.3 目标用户与场景

框架	主要用户	典型场景	企业适配度
dsh	Agent开发者/平台团队	构建定制Agent系统、企业级Agent平台	高（可深度定制）
Claude Code	开发者/工程师	使用Claude进行编码开发	中（模型绑定）
Codex CLI	开发者/DevOps	命令行编码任务、CI/CD集成	中（模型绑定）
OpenCode	开发者/技术团队	开源Agent方案、自托管部署	中高（可自托管）

二、架构设计维度对比

2.1 架构模式对比

维度	dsh	Claude Code	Codex CLI	OpenCode
架构范式	微内核+插件树	一体化设计+MCP扩展	模块化+工具链集成	插件化架构
核心框架	Cordis微内核	自研核心	自研Rust核心	Go插件系统
可替换范围	全部组件（含Agent Loop）	工具扩展为主	配置扩展	中等程度可替换
特权内核	无（一切皆插件）	有（核心循环写死）	有	有部分
扩展方式	插件+Profile+Bundle+Patch	MCP工具+配置	配置文件+hooks	插件系统+MCP
配置格式	YAML分层patch	JSON/配置文件	TOML配置	YAML配置

2.2 插件体系深度对比

插件维度	dsh	Claude Code	Codex CLI	OpenCode
插件机制	Cordis全能力插件	MCP工具扩展	Hook系统+工具注册	Go插件+MCP
可扩展的能力	12个核心Seam全部可换	工具/资源/提示词	工具/Hook/模型	工具/模型/存储
依赖注入	有（inject声明）	无	无	部分
生命周期管理	Fiber状态机	简单加载/卸载	简单注册	插件生命周期事件
热重载	支持（Profile patch）	部分支持	不支持	部分支持
插件分发	Bundle(npm包)	MCP服务器	配置引用	插件市场
卸载清理	自动（可逆副作用）	手动	手动	部分自动

关键差异：dsh的插件体系是结构性的——连Agent Loop和会话日志都是插件，其他框架的插件是功能性的——在固定核心上扩展功能。这个差异决定了：如果你需要一个可以深度定制的Agent平台底座，dsh的架构天花板最高；如果你只需要一个好用的Coding Agent，其他三个足够。

三、模型支持与可移植性

维度	dsh	Claude Code	Codex CLI	OpenCode
默认模型	DeepSeek系列	Claude系列	GPT-4o/GPT-4.1	多模型可选
模型绑定	不绑定，多Provider	强绑定Anthropic	强绑定OpenAI	不绑定
支持的模型数	DeepSeek/OpenAI/Anthropic/自定义	仅Anthropic	仅OpenAI	OpenAI/Anthropic/本地/更多
适配器模式	LlmAdapter Seam（可扩展）	无（内置）	无（内置）	Provider接口
本地模型支持	支持（自定义适配器）	不支持	不支持	支持（Ollama等）
模型切换成本	配置修改，零代码	不可切换	不可切换	配置切换
Tool-call格式	统一StreamChunk格式	Anthropic原生	OpenAI原生	各Provider原生

企业选型要点：如果有模型中立需求（比如需要同时支持国产模型和海外模型），dsh和OpenCode是更合适的选择。Claude Code和Codex CLI本质上是各自模型厂商的Agent产品，不是中立框架。

四、安全模型与权限控制

4.1 安全架构对比

安全维度	dsh	Claude Code	Codex CLI	OpenCode
工具执行前置检查	Waterfall多阶段pre-execute	单级权限检查	基础权限检查	Hook拦截
单调守卫	有（guard不可撤销）	无	无	无
沙箱机制	Sandbox Seam（失败即关闭）	内置限制	Docker隔离	进程级限制
沙箱后端	landlock/Docker/E2B（可替换）	内置（不可替换）	Docker	内置
审批机制	Approval插件+逐工具配置	全局确认/允许列表	权限等级	配置规则
凭据管理	Credentials Seam（加密+引用）	环境变量/Keychain	环境变量	配置文件
会话审计	仅追加事件日志	有限日志	命令历史	日志记录
Code Mode权限	同样经过权限管道	不适用	不适用	部分支持

4.2 安全策略深度对比

dsh安全模型（三层管道 + 单调守卫）：

  pre-execute waterfall → execute waterfall → post-execute waterfall

       ↑

  guard() 终态否决，不可被后续插件撤销

Claude Code安全模型：

  全局权限等级 → 逐工具确认 → 允许列表

Codex CLI安全模型：

  权限等级配置 → Docker沙箱 → 命令白名单

OpenCode安全模型：

  Hook拦截 → 进程限制 → 配置规则

企业安全场景下，dsh的waterfall+单调守卫模型最灵活——你可以叠加多层安全策略（企业合规、部门策略、项目规则），并且保证安全策略不会被后加载的插件绕过。但代价是配置复杂度更高。

五、多Agent与编排能力

维度	dsh	Claude Code	Codex CLI	OpenCode
多Agent支持	原生支持（Subagent Seam）	不支持	不支持	有限支持
子Agent后端	5种以上（Spawn/Fork/ACP/Claude/Codex）	无	无	进程内Spawn
跨框架子Agent	支持（可调度Claude/Codex）	不支持	不支持	不支持
Workflow编排	模型生成JS编排脚本	不支持	不支持	不支持
任务分解	Agent Loop内置	内置提示词	内置	插件扩展
子Agent权限	父级授权+Tool Filter	不适用	不适用	继承父权限
并行执行	支持（Workflow并行子代理）	不支持	不支持	部分支持
结构化输出	原生支持（JSON Schema）	部分支持	支持	支持

dsh的跨框架子Agent能力是一个独特优势——你可以把Claude Code和Codex当作子Agent来调度，让不同模型在各自擅长的任务上工作，用dsh做统一编排层。这对于已经在用多种AI工具的企业来说，是一个有价值的集成方案。

六、会话管理与可观测性

维度	dsh	Claude Code	Codex CLI	OpenCode
会话存储	事件源（仅追加日志）	消息列表	消息历史	消息列表
可回放性	完全支持（事件流回放）	不支持	不支持	不支持
可分叉性	支持（Fork子Agent）	不支持	不支持	不支持
上下文压缩	SurfaceOp替换，不改原始日志	简单截断	截断+缓存	截断
调试视图	Trajectory按来源查看	对话历史	命令历史	基础历史
持久化后端	SQLite/JSONL/自定义Seam	本地文件	本地文件	可配置
遥测集成	OTel原生	无	无	有限
版本控制	SESSION_FORMAT_VERSION机制	无	无	无

事件源会话是dsh的独特设计。其他三个框架都用传统的消息列表存储会话，而dsh把Agent的每一步（包括工具调用、压缩事件、上下文注入）都记录为事件。这个设计的价值在调试和审计场景下尤为突出——你可以精确回放Agent的每一步决策，而不只是看到最终的对话历史。

七、性能与资源消耗

维度	dsh	Claude Code	Codex CLI	OpenCode
启动速度	中（插件树加载）	快	快（Rust编译）	快（Go编译）
内存占用	中高（Node.js+插件）	中（Node.js）	低（Rust二进制）	低（Go二进制）
工具调用延迟	中（waterfall多层）	低	低	低
并发能力	高（事件驱动+多Agent）	低（单会话）	低（单会话）	中
冷启动时间	取决于插件数量	快	极快	快
长任务稳定性	高（事件源可恢复）	中	中	中
批量处理能力	高（Headless模式+并行）	低	中	中

性能方面，Rust编写的Codex CLI和Go编写的OpenCode有天然优势。dsh由于Node.js运行时和插件体系，资源消耗更高，但换来的是更强的扩展能力。对于单用户Coding Agent场景，性能差异可以忽略；对于大规模企业部署（数百并发Agent），资源消耗的差异会转化为显著的成本差异。

八、生态与社区

维度	dsh	Claude Code	Codex CLI	OpenCode
开源协议	MIT	Proprietary	MIT	Apache 2.0
GitHub Stars	快速增长中（新开源）	N/A	高	中高
贡献者数量	25+（官方为主）	N/A	较多	社区贡献
插件生态	初期（dsh-plugin话题）	MCP生态	较小	中等
文档完整度	中高（开发者预览）	高	高	中
企业支持	DeepSeek官方	Anthropic Enterprise	OpenAI Enterprise	社区/商业版
MCP支持	原生支持	原生支持	不支持	支持
ACP支持	原生支持	不支持	不支持	不支持

生态成熟度方面，Claude Code和Codex CLI虽然不开源，但依托Anthropic和OpenAI的生态资源，工具和集成更丰富。dsh虽然新，但MIT许可证和Everything is a Plugin的架构对开发者有很强的吸引力，社区增长很快。OpenCode作为社区驱动项目，生态最分散但也最开放。

九、企业选型决策矩阵

9.1 选型决策树

企业Agent框架选型决策树：

你是要一个Coding工具还是一个Agent平台底座？

  │

  ├─ Coding工具 → 你绑定哪个模型？

  │     ├─ Claude → Claude Code（最佳体验）

  │     ├─ GPT系列 → Codex CLI（原生集成）

  │     └─ 多模型/国产 → OpenCode（开源灵活）

  │

  └─ 平台底座 → 你需要多深的定制能力？

        ├─ 深度定制（换Agent Loop/沙箱/日志）→ dsh

        ├─ 中等定制（工具+工作流）→ dsh 或 OpenCode

        └─ 轻度定制（MCP工具）→ 都可以

9.2 场景化选型矩阵

企业场景	推荐框架	核心理由	注意事项
单一模型深度使用	Claude Code / Codex	原生体验最优	模型锁定风险
多模型混合策略	dsh / OpenCode	模型中立，灵活切换	适配成本
企业级Agent平台	dsh	深度定制+安全管道	学习曲线
开源自托管	dsh / OpenCode	完全可控	运维成本
安全合规严格	dsh	多层安全管道+审计日志	配置复杂度
快速原型验证	Claude Code / OpenCode	开箱即用	长期可扩展性
多Agent编排	dsh	原生Subagent+Workflow	架构复杂度
CI/CD集成	Codex CLI / dsh(headless)	命令行友好	脚本化程度

十、Python实战：Agent框架基准测试套件

以下Python代码实现了一个Agent框架基准测试套件，用于量化评估不同Agent框架在典型企业任务上的表现。包含任务完成率、工具调用准确率、Token效率和平均延迟四个核心指标的计算。

import json

import time

from dataclasses import dataclass, field

from typing import List, Dict, Optional

from pathlib import Path

from enum import Enum

class TaskType(Enum):

    SINGLE_TOOL = "single_tool"

    MULTI_TOOL = "multi_tool"

    CODE_GENERATION = "code_generation"

    FILE_EDITING = "file_editing"

    REASONING = "reasoning"

    ERROR_RECOVERY = "error_recovery"

@dataclass

class BenchmarkTask:

    task_id: str

    task_type: TaskType

    description: str

    expected_tools: List[str]

    success_criteria: str

    difficulty: int = 1  # 1-5

    max_steps: int = 10

@dataclass

class TaskResult:

    task_id: str

    framework: str

    success: bool = False

    steps_taken: int = 0

    tool_calls: int = 0

    tool_errors: int = 0

    total_tokens: int = 0

    prompt_tokens: int = 0

    completion_tokens: int = 0

    total_time_ms: float = 0.0

    first_token_ms: float = 0.0

    error_message: Optional[str] = None

@dataclass

class FrameworkScore:

    framework: str

    task_completion_rate: float = 0.0

    tool_accuracy: float = 0.0

    token_efficiency: float = 0.0

    avg_latency_ms: float = 0.0

    error_recovery_rate: float = 0.0

    total_score: float = 0.0

    task_results: List[TaskResult] = field(default_factory=list)

class AgentBenchmarkSuite:

    """Agent框架基准测试套件"""

    def __init__(self):

        self.tasks: List[BenchmarkTask] = []

        self.results: Dict[str, List[TaskResult]] = {}

        self.scores: Dict[str, FrameworkScore] = {}

    def add_task(self, task: BenchmarkTask):

        self.tasks.append(task)

    def add_result(self, framework: str, result: TaskResult):

        if framework not in self.results:

            self.results[framework] = []

        self.results[framework].append(result)

    def calculate_scores(self):

        """计算各框架的综合评分"""

        for framework, results in self.results.items():

            score = FrameworkScore(framework=framework)

            score.task_results = results

            # 任务完成率

            completed = sum(1 for r in results if r.success)

            score.task_completion_rate = completed / len(results) if results else 0

            # 工具调用准确率

            total_calls = sum(r.tool_calls for r in results)

            total_errors = sum(r.tool_errors for r in results)

            score.tool_accuracy = 1 - (total_errors / total_calls) if total_calls > 0 else 0

            # Token效率 = 完成率 / 千Token

            total_tokens = sum(r.total_tokens for r in results)

            if total_tokens > 0 and score.task_completion_rate > 0:

                score.token_efficiency = score.task_completion_rate / (total_tokens / 1000)

            # 平均延迟

            successful = [r for r in results if r.success]

            if successful:

                score.avg_latency_ms = sum(r.total_time_ms for r in successful) / len(successful)

            # 错误恢复率

            error_tasks = [r for r in results if r.tool_errors > 0]

            recovered = sum(1 for r in error_tasks if r.success)

            score.error_recovery_rate = recovered / len(error_tasks) if error_tasks else 1.0

            # 综合评分（加权）

            score.total_score = (

                score.task_completion_rate * 0.35 +

                score.tool_accuracy * 0.20 +

                min(score.token_efficiency / 0.1, 1.0) * 0.15 +

                max(0, 1 - score.avg_latency_ms / 30000) * 0.15 +

                score.error_recovery_rate * 0.15

            )

            self.scores[framework] = score

        return self.scores

    def generate_comparison_report(self) -> str:

        """生成横向对比报告"""

        if not self.scores:

            self.calculate_scores()

        lines = ["=" * 70]

        lines.append("Agent Framework Benchmark Comparison Report")

        lines.append("=" * 70)

        lines.append("")

        # 总览表

        frameworks = sorted(self.scores.keys(),

                          key=lambda f: self.scores[f].total_score, reverse=True)

        lines.append(f"{"Framework":<20} {"Score":>8} {"Completion":>10} {"Tool Acc":>9} {"Token Eff":>9} {"Latency":>10} {"Recovery":>10}")

        lines.append("-" * 70)

        for fw in frameworks:

            s = self.scores[fw]

            lines.append(f"{fw:<20} {s.total_score:>8.3f} {s.task_completion_rate:>9.1%} {s.tool_accuracy:>8.1%} {s.token_efficiency:>9.4f} {s.avg_latency_ms:>9.1f}ms {s.error_recovery_rate:>9.1%}")

        lines.append("")

        lines.append("Task Type Breakdown:")

        lines.append("-" * 70)

        # 按任务类型分解

        for task_type in TaskType:

            lines.append(f"\n  {task_type.value}:")

            for fw in frameworks:

                type_results = [r for r in self.scores[fw].task_results

                                 if self._get_task(r.task_id).task_type == task_type]

                if type_results:

                    rate = sum(1 for r in type_results if r.success) / len(type_results)

                    lines.append(f"    {fw:<20} {rate:>6.1%} ({len(type_results)} tasks)")

        return "\n".join(lines)

    def _get_task(self, task_id: str) -> Optional[BenchmarkTask]:

        for t in self.tasks:

            if t.task_id == task_id:

                return t

        return None

    def export_json(self, path: str):

        """导出基准测试结果为JSON"""

        data = {

            "tasks": [t.__dict__ for t in self.tasks],

            "results": {k: [r.__dict__ for r in v] for k, v in self.results.items()},

            "scores": {k: v.__dict__ for k, v in self.scores.items()},

        }

        with open(path, "w", encoding="utf-8") as f:

            json.dump(data, f, indent=2, default=str)

    def build_enterprise_task_suite(self):

        """构建企业场景基准测试任务集"""

        tasks = [

            BenchmarkTask(

                task_id="ent-001",

                task_type=TaskType.SINGLE_TOOL,

                description="读取指定文件并总结内容",

                expected_tools=["read_file"],

                success_criteria="成功读取并输出文件摘要",

                difficulty=1,

            ),

            BenchmarkTask(

                task_id="ent-002",

                task_type=TaskType.MULTI_TOOL,

                description="在代码库中搜索函数定义并解释",

                expected_tools=["grep_search", "read_file"],

                success_criteria="找到函数并给出合理解释",

                difficulty=2,

            ),

            BenchmarkTask(

                task_id="ent-003",

                task_type=TaskType.FILE_EDITING,

                description="修复Python文件中的语法错误",

                expected_tools=["read_file", "edit_file"],

                success_criteria="语法错误被修复，代码可运行",

                difficulty=2,

            ),

            BenchmarkTask(

                task_id="ent-004",

                task_type=TaskType.CODE_GENERATION,

                description="创建一个REST API端点并添加测试",

                expected_tools=["write_file", "run_command"],

                success_criteria="API创建完成，测试通过",

                difficulty=3,

            ),

            BenchmarkTask(

                task_id="ent-005",

                task_type=TaskType.ERROR_RECOVERY,

                description="运行测试失败后修复代码并重新运行",

                expected_tools=["run_command", "read_file", "edit_file"],

                success_criteria="修复后测试全部通过",

                difficulty=3,

            ),

            BenchmarkTask(

                task_id="ent-006",

                task_type=TaskType.REASONING,

                description="分析代码库结构并给出重构建议",

                expected_tools=["find_files", "read_file"],

                success_criteria="给出结构化的重构分析报告",

                difficulty=4,

            ),

            BenchmarkTask(

                task_id="ent-007",

                task_type=TaskType.MULTI_TOOL,

                description="配置CI/CD流水线并部署到测试环境",

                expected_tools=["write_file", "run_command", "edit_file"],

                success_criteria="流水线配置完成，部署成功",

                difficulty=4,

            ),

            BenchmarkTask(

                task_id="ent-008",

                task_type=TaskType.REASONING,

                description="诊断生产环境性能问题并提出优化方案",

                expected_tools=["run_command", "read_file", "grep_search"],

                success_criteria="准确定位瓶颈并给出可执行的优化方案",

                difficulty=5,

            ),

        ]

        for t in tasks:

            self.add_task(t)

        print(f"Enterprise task suite loaded: {len(tasks)} tasks")

这套基准测试套件涵盖了企业Agent的典型任务场景，从单工具操作到多步骤推理，从代码生成到错误恢复。通过统一的指标体系（完成率35% + 工具准确率20% + Token效率15% + 延迟15% + 错误恢复15%），可以客观量化不同框架在企业场景下的实际表现。建议在选型前用真实业务数据跑一遍这个测试套件，而不是仅凭功能列表做决策。

十一、总评分与最终推荐

11.1 综合评分雷达

评价维度	权重	dsh	Claude Code	Codex CLI	OpenCode
架构可扩展性	20%	9.5	5.0	4.0	7.0
模型中立性	15%	9.0	1.0	1.0	8.5
安全模型	15%	9.0	6.5	7.0	6.0
开箱即用	10%	6.0	9.0	8.5	7.5
编码体验	15%	7.5	9.5	9.0	8.0
多Agent能力	10%	9.5	2.0	2.0	4.0
生态成熟度	10%	6.5	9.0	8.5	7.0
企业适配性	5%	9.0	6.0	5.0	7.5
加权总分	100%	8.4	6.5	5.9	7.0

11.2 各框架优劣势总结

框架	核心优势	主要劣势	最适合的团队
DeepSeek Harness	架构最灵活、安全模型最强、多Agent能力最强、完全开源	学习曲线陡、生态尚早、资源消耗较高	需要构建企业Agent平台的团队
Claude Code	Claude模型体验最佳、开箱即用、生态丰富	不开源、绑定Anthropic、价格高	以Claude为主力模型的开发团队
Codex CLI	OpenAI原生体验、Rust高性能、简洁高效	绑定OpenAI、扩展性有限	使用GPT系列的DevOps团队
OpenCode	开源免费、多模型支持、Go高性能	社区驱动、功能不够深入	需要自托管的中小团队

11.3 2026年选型建议

• 如果你在选型Coding Agent工具：Claude Code体验最好，Codex CLI最快，OpenCode最开放。根据你主力模型选就行，差距不大。
• 如果你在选型Agent平台底座：dsh是目前开源界架构最先进的选项，虽然生态还在早期，但Everything is a Plugin的设计让它的天花板远高于其他框架。
• 如果你需要混合使用多个模型：dsh和OpenCode是唯二的模型中立选项，dsh胜在架构深度，OpenCode胜在成熟度。
• 如果你有严格的安全合规要求：dsh的waterfall安全管道+单调守卫+事件源审计日志是目前最完善的企业级安全模型，值得认真评估。
• 如果你关注长期演进：Agent框架赛道还在早期，选择开源框架（dsh/Codex/OpenCode）比选择闭源产品（Claude Code）有更高的长期可控性。

十二、总结

维度	核心结论
架构领先性	dsh的微内核+插件树架构最先进，其他三家仍是一体化设计
安全模型	dsh的waterfall三层管道+单调守卫最完善，企业级最可靠
多Agent能力	dsh原生支持且跨框架调度，其他三家基本不支持
编码体验	Claude Code和Codex CLI凭借原生优化，体验更流畅
生态成熟度	Claude Code > Codex CLI > OpenCode > dsh（新开源）
企业平台底座	dsh是唯一真正可以当平台底座用的框架
开源程度	dsh(MIT) = Codex(MIT) > OpenCode(Apache) >> Claude Code(闭源)
2026年趋势	Agent框架从工具层面向平台层演进，dsh代表了方向

四大Agent框架各有定位，没有绝对的好坏，只有适合不适合。Claude Code和Codex CLI是优秀的Coding Agent产品，开箱即用，体验一流，但它们是产品不是框架——你只能在厂商划定的边界内使用。dsh和OpenCode是真正的框架，其中dsh的架构理念最激进也最先进，Everything is a Plugin不只是口号，而是从Agent Loop到会话日志、从安全管道到UI界面的全方位贯彻。

对于企业来说，关键问题不是哪个框架最好，而是你需要一个工具还是一个底座。如果只是让开发者写代码更快，Claude Code或Codex CLI就够了；如果要构建覆盖全企业的Agent平台，连接内部系统、执行复杂工作流、满足安全合规要求，那dsh的架构天花板值得你投入时间去研究。2026年的Agent框架竞争，才刚刚开始。

紫宸策 | GEO咨询与企业AI落地实践

公众号：紫宸策