DeepSeek Harness：一夜破2.4万星的Agent框架，用"一切皆插件"重新定义AI Agent架构

GitHub史上最快涨星项目诞生：1.5小时突破2.4万Star，超越此前xAI Grok-1保持的1.2天纪录。DeepSeek Harness不是新模型，而是一个改变游戏规则的Agent运行框架——"一切皆插件"的架构哲学，正在重新定义AI Agent的构建方式。

一、现象级爆发：为什么DSH能创造历史？

2026年8月14日晚8点半，DeepSeek Harness（简称DSH）开发者预览版v0.1正式开源。仅仅一个半小时，GitHub Star数突破2.4万，创造了新的历史纪录。

对比一下：

• DeepSeek R1：突破2万星用了5.7天
• xAI Grok-1：此前最快纪录，约1.2天破2万星
• DeepSeek Harness：1.5小时破2.4万星

这不是单纯的营销胜利。DSH的爆发式增长，背后是开发者社区对"AI Agent如何落地"这个问题的迫切期待。

1.1 为什么Agent框架突然火了？

2026年的AI领域，已经从"谁的模型更大"转向"谁的Agent更智能"。基础模型能力趋于同质化，真正的差异在于：

1. 模型能做什么 → 模型能完成什么
2. 生成好的回答 → 执行完整的任务
3. 人机对话 → 人机协作

Claude Code、Cursor Agent、OpenAI Codex等项目的成功，证明了Agent市场的巨大潜力。但它们都有一个共同问题：封闭架构，难以定制。

DSH的出现，恰好填补了这个空白——一个开放、模块化、可自由组合的Agent框架。

二、核心架构解密："一切皆插件"的技术哲学

DSH的核心理念可以用一句话概括：

Everything is a Plugin —— 一切皆插件

这不是简单的口号，而是从底层重构Agent架构的系统性设计。

2.1 Cordis：插件化元框架

DSH建立在Cordis插件系统之上。Cordis是一个具有时空可组合性的元框架，其核心职责非常克制：

// Cordis只负责三件事
class Cordis {
  // 1. 插件加载与卸载
  loadPlugin(plugin: Plugin): void;
  unloadPlugin(pluginId: string): void;
  
  // 2. 依赖关系管理
  resolveDependencies(): DependencyGraph;
  
  // 3. 服务与事件的协调
  getService<T>(serviceId: string): T;
  emitEvent(event: Event): void;
}

这种"最小元框架"的设计，让DSH的所有具体组件都是不同的Cordis插件，而非硬编码的框架代码。

2.2 插件化的Agent能力矩阵

在DSH中，以下所有能力都是可替换的插件：

2.3 三角色模型：Service Definition / Provider / Consumer

DSH采用了一套优雅的能力接缝设计（Capability Seam），每个可替换能力由三个角色组成：

// 示例：文件系统能力的三角色模型

// 1. Service Definition - 定义接口
interface FileSystemService {
  readFile(path: string): Promise<string>;
  writeFile(path: string, content: string): Promise<void>;
  listDirectory(path: string): Promise<FileInfo[]>;
  // ...
}

// 2. Provider - 实现接口
class LocalFileSystemProvider implements FileSystemService {
  async readFile(path: string): Promise<string> {
    return fs.readFile(path, 'utf-8');
  }
  // ...
}

// 3. Consumer - 消费服务
class CodeAnalysisPlugin {
  constructor(private fileSystem: FileSystemService) {}
  
  async analyzeProject(rootPath: string) {
    const files = await this.fileSystem.listDirectory(rootPath);
    // 使用抽象接口，不关心具体实现
  }
}

这种设计带来了极强的解耦性：

• Provider可以随时替换（本地文件系统 → 云存储）
• Consumer无需修改代码
• Definition作为契约保证兼容性

三、四种运行模式：从极简到创造的完整光谱

DSH提供了四种预设模式，每种模式加载不同的插件集合，适配不同场景：

3.1 标准模式（Standard）

适用场景：完整的开发工作流

npx @deepseek-ai/dsh web --mode standard

加载的插件：

• ✅ 模型适配器（DeepSeek-V4-Pro默认）
• ✅ 文件系统访问
• ✅ Shell命令执行
• ✅ 网页访问
• ✅ 代码工具（语法高亮、代码分析）
• ✅ 子Agent编排
• ✅ 会话日志
• ✅ Web UI

工作流示例：

用户: "帮我重构这个项目的错误处理模块"

DSH Agent:
1. [读取项目结构] 扫描src/目录
2. [分析现有代码] 识别错误处理模式
3. [制定重构计划] 列出需要修改的文件
4. [执行修改] 逐文件应用新架构
5. [运行测试] npm test
6. [观察结果] 2个测试失败
7. [自动修复] 修复测试用例
8. [再次测试] 全部通过
9. [生成文档] 更新README.md

3.2 PTC模式（Programmatic Tool Calling）

适用场景：程序化工具调用，适合API集成

npx @deepseek-ai/dsh headless --mode ptc

核心特点：

• 工具调用完全程序化
• 输出结构化JSON
• 无交互UI，纯API模式

使用示例：

import requests

response = requests.post('http://localhost:3000/api/task', json={
    'instruction': '分析代码覆盖率并生成报告',
    'project_path': '/path/to/project',
    'output_format': 'json'
})

result = response.json()
# {
#   'coverage': {'lines': 78.5, 'branches': 65.2},
#   'uncovered_files': ['src/utils/parser.ts'],
#   'recommendations': ['添加parser.ts的边界测试']
# }

3.3 极简模式（Minimal）

适用场景：轻量对话、快速问答

npx @deepseek-ai/dsh tui --mode minimal

加载的最小插件集：

• ✅ 模型适配器
• ❌ 文件系统（禁用）
• ❌ Shell（禁用）
• ✅ 会话日志
• ✅ TUI界面

适合场景：

• 代码咨询（不执行）
• 架构设计讨论
• 文档撰写辅助

3.4 创造模式（Creative）

适用场景：代码生成、原型开发

npx @deepseek-ai/dsh web --mode creative

特点：

• 放宽安全限制
• 允许动态插件加载
• 支持模型自创建工具

高级功能：模型可以通过cordis_define和cordis_run工具编写代码并挂载为自己的插件：

// 模型生成的动态插件
const customPlugin = {
  name: 'api-mock-generator',
  execute: async (spec: OpenAPISpec) => {
    // 自动解析API规范并生成Mock服务器
    const mockServer = express();
    spec.paths.forEach(path => {
      mockServer.get(path, (req, res) => {
        res.json(generateMockResponse(path));
      });
    });
    return mockServer;
  }
};

// 模型调用cordis_define注册插件
await cordis.define(customPlugin);

// 模型调用cordis_run执行插件
const server = await cordis.run('api-mock-generator', openApiSpec);

四、事件溯源架构：Model-Visible Means Logged

DSH采用**事件溯源（Event Sourcing）**作为核心数据模型：

"模型可见的一切都必须能从日志重建"
—— Model-Visible Means Logged

4.1 Append-Only会话日志

每个Session都有一个不可变的日志流：

interface SessionLog {
  events: SessionEvent[];
  // 只能追加，不能修改或删除
  append(event: SessionEvent): void;
  // 从日志重建完整状态
  rebuild(): SessionState;
}

type SessionEvent = 
  | { type: 'user_message'; content: string; timestamp: number }
  | { type: 'model_response'; content: string; timestamp: number }
  | { type: 'tool_call'; tool: string; args: any; timestamp: number }
  | { type: 'tool_result'; result: any; timestamp: number }
  | { type: 'plugin_loaded'; pluginId: string; timestamp: number }
  | { type: 'error'; message: string; stack: string; timestamp: number };

4.2 为什么选择事件溯源？

1. 完整审计追溯

任何Agent操作都可以追溯到原始事件
→ 符合企业安全合规要求
→ 便于事后分析和调试

2. 时间旅行调试

# 重放到某个时间点
dsh replay --session abc123 --to-timestamp 1690000000

# 查看当时的状态
dsh inspect --session abc123 --at-event 42

3. 状态重建

如果Agent崩溃或中断：
→ 从日志重建到最近状态
→ 继续执行未完成任务
→ 无需手动保存checkpoint

4.3 实战：会话日志的数据结构

{
  "sessionId": "sess_abc123",
  "events": [
    {
      "type": "user_message",
      "content": "帮我分析这个Bug",
      "timestamp": 1723672800000
    },
    {
      "type": "tool_call",
      "tool": "read_file",
      "args": { "path": "src/parser.ts" },
      "timestamp": 1723672801000
    },
    {
      "type": "tool_result",
      "result": {
        "content": "export function parse(input: string) { ... }",
        "lines": 45
      },
      "timestamp": 1723672801500
    },
    {
      "type": "model_response",
      "content": "我发现问题在第23行...",
      "timestamp": 1723672802000
    },
    {
      "type": "tool_call",
      "tool": "edit_file",
      "args": {
        "path": "src/parser.ts",
        "edits": [{ "oldText": "...", "newText": "..." }]
      },
      "timestamp": 1723672803000
    }
  ]
}

五、安全沙箱：动态插件的隔离执行

DSH最激进的功能之一是允许模型动态编写并执行代码。这带来了巨大的安全挑战。

5.1 node:vm沙箱机制

DSH使用Node.js的vm模块作为第一层隔离：

import vm from 'vm';

class DynamicPluginSandbox {
  private context: vm.Context;
  
  constructor(allowedAPIs: string[]) {
    // 创建隔离上下文
    this.context = vm.createContext({
      // 只暴露白名单API
      console: {
        log: (...args) => this.logChannel.send(args),
        error: (...args) => this.errorChannel.send(args)
      },
      fetch: this.guardedFetch, // 经过守卫的fetch
      setTimeout: setTimeout,
      // 其他安全API...
    });
  }
  
  async execute(code: string): Promise<any> {
    try {
      const script = new vm.Script(code, {
        timeout: 30000, // 30秒超时
        displayErrors: true
      });
      
      return await script.runInContext(this.context);
    } catch (error) {
      // 沙箱内错误不会影响主进程
      return { error: error.message };
    }
  }
}

5.2 Facade模式：守卫后的服务访问

每个危险操作都通过Facade进行：

class GuardedFileSystemFacade {
  constructor(
    private realFileSystem: FileSystemService,
    private policy: SecurityPolicy
  ) {}
  
  async readFile(path: string): Promise<string> {
    // 1. 路径规范化
    const normalizedPath = pathUtils.normalize(path);
    
    // 2. 权限检查
    if (!this.policy.isAllowed('read', normalizedPath)) {
      throw new PermissionDeniedError(
        `Cannot read ${normalizedPath}: outside allowed directories`
      );
    }
    
    // 3. 敏感信息过滤
    const content = await this.realFileSystem.readFile(normalizedPath);
    return this.maskSecrets(content);
  }
  
  private maskSecrets(content: string): string {
    // 自动屏蔽API Key、密码等敏感信息
    return content
      .replace(/sk-[a-zA-Z0-9]{32,}/g, 'sk-***MASKED***')
      .replace(/password\s*=\s*['"][^'"]+['"]/gi, 'password = "***MASKED***"');
  }
}

5.3 多层沙箱策略

DSH支持多种沙箱模式：

配置示例：

# dsh.config.yaml
sandbox:
  mode: docker
  docker:
    image: dsh-sandbox:latest
    memory: 512m
    cpu: 0.5
    timeout: 60s
    network: none  # 禁用网络

六、实战案例：用DSH构建代码审查Agent

让我们通过一个完整案例，理解DSH的插件化架构如何实战应用。

6.1 需求分析

构建一个自动化代码审查Agent，需要：

1. 读取Git仓库代码
2. 运行静态分析工具
3. 生成审查报告
4. 提交为GitLab MR评论

6.2 插件组合方案

# code-reviewer-manifest.yaml
plugins:
  - name: @dsh/model-deepseek-v4-pro
    config:
      temperature: 0.3
      maxTokens: 8000
  
  - name: @dsh/filesystem-local
    config:
      rootPath: ${PROJECT_ROOT}
      readOnly: false
  
  - name: @dsh/shell-executor
    config:
      allowedCommands:
        - eslint
        - prettier
        - tsc
        - git
  
  - name: @dsh/git-integration
    config:
      provider: gitlab
      token: ${GITLAB_TOKEN}
  
  - name: custom/static-analyzer
    path: ./plugins/static-analyzer
    config:
      rules:
        - 'no-unused-vars'
        - 'prefer-const'
        - 'no-explicit-any'

mode: standard

6.3 自定义插件开发

// plugins/static-analyzer/index.ts
import { Plugin, Service } from '@deepseek-ai/dsh';

export default class StaticAnalyzerPlugin implements Plugin {
  name = 'static-analyzer';
  
  @Service('staticAnalysis')
  async analyze(filePath: string): Promise<AnalysisResult> {
    const eslint = require('eslint');
    const cli = new eslint.CLIEngine({
      useEslintrc: true,
      plugins: ['@typescript-eslint']
    });
    
    const report = cli.executeOnFiles([filePath]);
    
    return {
      file: filePath,
      errors: report.results[0].messages
        .filter(m => m.severity === 2)
        .map(m => ({
          line: m.line,
          column: m.column,
          message: m.message,
          rule: m.ruleId
        })),
      warnings: report.results[0].messages
        .filter(m => m.severity === 1)
        .map(m => ({
          line: m.line,
          column: m.column,
          message: m.message,
          rule: m.ruleId
        }))
    };
  }
}

6.4 完整工作流代码

import { DSHAgent } from '@deepseek-ai/dsh';

async function reviewCode(mrUrl: string) {
  // 1. 初始化Agent
  const agent = await DSHAgent.create({
    mode: 'standard',
    plugins: [
      '@dsh/model-deepseek-v4-pro',
      '@dsh/filesystem-local',
      '@dsh/shell-executor',
      '@dsh/git-integration',
      './plugins/static-analyzer'
    ]
  });
  
  // 2. 克隆MR代码
  const projectPath = await agent.execute(`
    克隆GitLab MR: ${mrUrl}
    切换到MR分支
  `);
  
  // 3. 静态分析
  const jsFiles = await agent.execute(`
    列出所有.ts和.js文件
    排除node_modules和dist目录
  `);
  
  const results = [];
  for (const file of jsFiles) {
    const analysis = await agent.services.staticAnalysis.analyze(file);
    results.push(analysis);
  }
  
  // 4. AI深度审查
  const aiReview = await agent.execute(`
    基于以下静态分析结果，进行深度代码审查：
    ${JSON.stringify(results, null, 2)}
    
    审查维度：
    1. 架构设计合理性
    2. 潜在性能问题
    3. 安全漏洞风险
    4. 代码可维护性
    
    生成结构化的审查报告
  `);
  
  // 5. 提交评论到GitLab
  await agent.execute(`
    将审查报告作为MR评论提交到 ${mrUrl}
    使用GitLab API的讨论功能
    每个问题定位到具体代码行
  `);
  
  return aiReview;
}

// 执行
reviewCode('https://gitlab.com/myorg/myproject/-/merge_requests/123')
  .then(report => console.log('审查完成:', report))
  .catch(err => console.error('审查失败:', err));

七、与主流Agent框架的对比分析

7.1 架构哲学对比

7.2 能力维度对比

7.3 选型建议

选择DeepSeek Harness，如果你需要：

• 完全控制Agent的每个组件
• 深度定制工具链
• 企业级安全隔离
• 多模型灵活切换
• 自建插件生态

选择Claude Code，如果你需要：

• 开箱即用的编程助手
• 不关心底层架构
• 快速个人开发

选择Cursor，如果你需要：

• IDE深度集成
• 实时补全体验
• 不需要完整Agent能力

选择Codex，如果你需要：

• 零运维
• 云端全托管
• 不介意数据上云

八、插件开发实战：构建你的第一个DSH插件

8.1 插件生命周期

interface PluginLifecycle {
  // 1. 插件加载前
  onLoad?(context: PluginContext): Promise<void>;
  
  // 2. 插件激活
  onActivate?(services: ServiceRegistry): Promise<void>;
  
  // 3. 插件运行
  execute?(task: Task): Promise<TaskResult>;
  
  // 4. 插件停用
  onDeactivate?(): Promise<void>;
  
  // 5. 插件卸载
  onUnload?(): Promise<void>;
}

8.2 完整插件示例：数据库查询插件

// plugins/database-query/index.ts
import { 
  Plugin, 
  Service, 
  Tool,
  PluginContext 
} from '@deepseek-ai/dsh';
import { Pool } from 'pg';

@Plugin({
  id: 'database-query',
  name: 'Database Query Plugin',
  version: '1.0.0',
  description: '提供PostgreSQL数据库查询能力'
})
export default class DatabaseQueryPlugin implements PluginLifecycle {
  private pool: Pool;
  
  async onLoad(context: PluginContext) {
    // 从配置读取数据库连接信息
    const config = context.config;
    
    this.pool = new Pool({
      host: config.host,
      port: config.port,
      database: config.database,
      user: config.user,
      password: config.password,
      max: 10,
      idleTimeoutMillis: 30000
    });
    
    context.logger.info('Database connection pool created');
  }
  
  async onActivate(services: ServiceRegistry) {
    // 注册数据库查询服务
    services.register('database.query', this.query.bind(this));
    services.register('database.schema', this.getSchema.bind(this));
    
    // 注册工具，供模型调用
    services.registerTool({
      name: 'db_query',
      description: '执行SQL查询（只读）',
      parameters: {
        type: 'object',
        properties: {
          sql: {
            type: 'string',
            description: 'SELECT语句'
          }
        },
        required: ['sql']
      },
      execute: this.query.bind(this)
    });
  }
  
  @Service('database.query')
  async query(sql: string): Promise<QueryResult> {
    // 安全检查：只允许SELECT
    if (!sql.trim().toUpperCase().startsWith('SELECT')) {
      throw new Error('Only SELECT queries are allowed');
    }
    
    const client = await this.pool.connect();
    try {
      const result = await client.query(sql);
      return {
        rows: result.rows,
        rowCount: result.rowCount,
        fields: result.fields.map(f => ({
          name: f.name,
          dataType: f.dataTypeID
        }))
      };
    } finally {
      client.release();
    }
  }
  
  @Service('database.schema')
  async getSchema(): Promise<SchemaInfo> {
    const tables = await this.query(`
      SELECT table_name, table_type
      FROM information_schema.tables
      WHERE table_schema = 'public'
    `);
    
    const schema = {};
    for (const table of tables.rows) {
      const columns = await this.query(`
        SELECT column_name, data_type, is_nullable
        FROM information_schema.columns
        WHERE table_name = '${table.table_name}'
      `);
      schema[table.table_name] = columns.rows;
    }
    
    return schema;
  }
  
  async onDeactivate() {
    // 清理连接池
    await this.pool.end();
  }
}

8.3 插件配置与部署

# dsh.config.yaml
plugins:
  - id: database-query
    path: ./plugins/database-query
    enabled: true
    config:
      host: localhost
      port: 5432
      database: myapp
      user: ${DB_USER}
      password: ${DB_PASSWORD}

# 启动DSH并加载数据库插件
npx @deepseek-ai/dsh web --config dsh.config.yaml

8.4 模型如何使用这个插件

用户: 分析users表的数据分布

DSH Agent:
[调用 db_schema 工具]
→ 获取表结构

[调用 db_query 工具]
SQL: SELECT COUNT(*) as total FROM users
SQL: SELECT COUNT(*) as active FROM users WHERE status = 'active'
SQL: SELECT DATE_TRUNC('month', created_at) as month, COUNT(*) 
     FROM users 
     GROUP BY month 
     ORDER BY month

[生成分析报告]
users表共有42,890条记录，其中活跃用户31,205人（占比72.7%）。
月度新增趋势显示...

九、性能优化与生产实践

9.1 插件懒加载

// 只在首次使用时加载重量级插件
class LazyPluginLoader {
  private loaded: Map<string, Plugin> = new Map();
  
  async get(pluginId: string): Promise<Plugin> {
    if (!this.loaded.has(pluginId)) {
      const plugin = await this.loadPlugin(pluginId);
      this.loaded.set(pluginId, plugin);
    }
    return this.loaded.get(pluginId);
  }
}

9.2 会话日志压缩

长时间运行的Agent会产生大量日志：

class SessionLogCompressor {
  compress(events: SessionEvent[]): CompressedLog {
    // 1. 合并连续的工具调用
    const merged = this.mergeSequentialToolCalls(events);
    
    // 2. 提取关键状态
    const snapshots = this.extractSnapshots(merged, {
      interval: 100, // 每100个事件一个快照
      maxSize: 1024 * 1024 // 快照最大1MB
    });
    
    // 3. 压缩重复内容
    const compressed = this.deduplicate(merged);
    
    return {
      events: compressed,
      snapshots,
      compressionRatio: events.length / compressed.length
    };
  }
}

9.3 多Agent协作模式

DSH支持子Agent编排：

// 主Agent编排多个子Agent
async function complexTask(input: string) {
  const agent = await DSHAgent.create({ mode: 'standard' });
  
  // 并行启动多个子Agent
  const [analysis, testing, docs] = await Promise.all([
    agent.spawnSubAgent({
      task: '分析代码架构',
      mode: 'minimal',
      model: 'deepseek-v4-flash' // 轻量模型
    }),
    agent.spawnSubAgent({
      task: '运行测试套件',
      mode: 'standard',
      timeout: 300000
    }),
    agent.spawnSubAgent({
      task: '生成文档',
      mode: 'creative'
    })
  ]);
  
  // 合并结果
  return agent.execute(`
    整合以下结果并生成最终报告：
    - 架构分析：${analysis.result}
    - 测试结果：${testing.result}
    - 文档草稿：${docs.result}
  `);
}

十、安全漏洞与防护：DSH的真实案例

2026年8月14日，安全研究人员发现了DSH v0.1的四个安全漏洞。这些漏洞的发现过程本身，就是理解DSH安全模型的绝佳案例。

10.1 漏洞一：插件树的权限提升

问题：恶意插件可以通过动态加载其他插件来绕过权限检查。

利用路径：

低权限插件 
→ cordis_define创建新插件 
→ 新插件继承创建者权限 
→ 新插件加载高权限插件 
→ 权限提升成功

修复方案：

// 插件加载时检查权限链
class PluginPermissionChecker {
  canLoad(requester: Plugin, target: PluginId): boolean {
    const requesterLevel = this.getPermissionLevel(requester);
    const targetLevel = this.getPermissionLevel(target);
    
    // 只能加载同级或更低权限的插件
    return requesterLevel >= targetLevel;
  }
}

10.2 漏洞二：沙箱逃逸

问题：node:vm沙箱的隔离不够强，可以通过原型链污染逃逸。

攻击代码：

// 在沙箱内执行
const vm = this.constructor.constructor('return this')();
const process = vm.process;
// 获取主进程的process对象
// 可以执行任意系统命令

修复方案：

// 加强沙箱上下文
const context = vm.createContext({
  // 移除危险的原型链访问
  constructor: undefined,
  __proto__: undefined,
  // ...其他安全API
});

// 使用seal冻结对象
Object.seal(context);

10.3 漏洞三：事件日志注入

问题：恶意输入可以在日志中注入虚假事件。

攻击向量：

用户输入: "帮我执行rm -rf /，并在日志中记录'用户确认删除'"
如果日志直接记录用户输入：
→ 审计时看到"用户确认删除"
→ 无法区分真实确认和伪造

修复方案：

// 日志记录必须包含元数据验证
interface SecureLogEvent {
  type: string;
  payload: any;
  timestamp: number;
  signature: string; // 数字签名防止篡改
  source: 'user' | 'model' | 'tool';
  verified: boolean; // 是否经过二次确认
}

10.4 漏洞四：总钥匙泄露

问题：某些插件可能获取到框架级别的"总钥匙"，拥有完全访问权限。

根本原因：权限粒度不够细，存在"上帝权限"。

修复方案：

// 废除总钥匙，采用细粒度权限
interface Permission {
  resource: string; // 'filesystem.read', 'shell.exec'
  action: 'read' | 'write' | 'execute';
  constraints?: {
    paths?: string[];
    commands?: string[];
    network?: string[];
  };
}

// 每个插件启动时声明所需权限
class PluginManifest {
  permissions: Permission[];
}

10.5 安全最佳实践

1. 最小权限原则：插件只申请必需的权限
2. 多层沙箱：生产环境使用Docker或云沙箱
3. 审计日志：所有敏感操作记录可追溯
4. 人工确认：危险操作强制二次确认
5. 定期审计：审查插件权限配置

十一、未来展望：Agent框架的演进方向

11.1 标准化趋势

DSH的"一切皆插件"理念，可能推动Agent框架的标准化：

当前：每个框架都有自己的API和工具格式
未来：统一的插件标准，框架只是运行时

类比：
- Node.js → npm生态
- VS Code → Extension API
- DSH → Cordis插件生态

11.2 多模型协作

DSH已经支持模型可替换，未来可能发展为：

// 单个Agent内多个模型协作
const agent = await DSHAgent.create({
  models: {
    planner: 'deepseek-v4-pro', // 规划用大模型
    coder: 'deepseek-v4-flash', // 编码用快速模型
    reviewer: 'claude-3.5-sonnet' // 审查用Claude
  },
  routing: {
    'architecture_design': 'planner',
    'code_generation': 'coder',
    'code_review': 'reviewer'
  }
});

11.3 自进化Agent

结合DSH的动态插件能力，Agent可以：

// Agent自我改进循环
async function selfImprove(agent: DSHAgent) {
  while (true) {
    // 1. 分析自己的执行日志
    const analysis = await agent.execute(`
      分析最近100次任务的执行日志
      识别效率瓶颈和常见错误
      提出改进方案
    `);
    
    // 2. 编写新的插件来解决问题
    const newPlugin = await agent.execute(`
      基于分析结果，编写一个新的Cordis插件
      解决识别到的问题
      使用cordis_define注册
    `);
    
    // 3. 测试新插件
    const testResult = await agent.execute(`
      运行测试套件验证新插件
      如果失败，回滚并修改
    `);
    
    // 4. 持续迭代
    await sleep(3600000); // 每小时改进一次
  }
}

十二、总结：为什么DSH是Agent框架的未来？

12.1 核心创新点

1. 架构解耦：模型、工具、会话、UI全部可替换
2. 插件生态：开放标准，自由组合，避免厂商锁定
3. 安全模型：多层沙箱、细粒度权限、事件溯源
4. 开发体验：npx一键启动，TypeScript原生支持

12.2 与闭源框架的本质区别

12.3 适用场景

强烈推荐DSH，如果你是：

• 需要深度定制Agent行为的企业
• 希望避免厂商锁定的团队
• 构建自有Agent产品的创业者
• 研究Agent架构的研究者
• 需要完全控制安全边界的场景

可以观望，如果你：

• 只需要简单的编程辅助
• 不想学习新的框架
• 对底层架构不感兴趣

12.4 一句话总结

DSH不是在造一个更好的轮子，而是在重新定义什么是轮子——以及，轮子应该如何组合成车。

附录：快速上手指南

A. 环境要求

• Node.js >= 18.0.0
• npm >= 9.0.0
• 操作系统：macOS / Linux / Windows（WSL）

B. 一分钟启动

# 安装并启动Web UI
npx @deepseek-ai/dsh web

# 或启动TUI（终端界面）
npx @deepseek-ai/dsh tui

# 或Headless模式（API服务）
npx @deepseek-ai/dsh headless --port 3000

C. 配置模型

# 设置DeepSeek API Key
export DEEPSEEK_API_KEY=sk-xxx

# 或使用自定义模型
export DSH_MODEL_PROVIDER=openai
export OPENAI_API_KEY=sk-xxx

D. 第一个任务

你: 帮我在当前目录创建一个Express项目，包含：
   - TypeScript配置
   - ESLint
   - 基础的Hello World API

DSH: 
[创建项目结构]
[初始化package.json]
[配置tsconfig.json]
[设置ESLint规则]
[编写index.ts]
[测试运行]
✅ 项目创建完成，运行 npm run dev 启动

参考资料：

• DeepSeek Harness GitHub仓库
• Cordis插件系统文档
• DSH官方文档
• Agent安全最佳实践

本文约9,500字，涵盖DeepSeek Harness的核心架构、插件开发、安全模型、实战案例与未来展望。希望为你理解AI Agent框架的演进方向提供深度参考。