1. 项目概述：DeepSeek Harness 的 Cordis 插件架构到底在解决什么问题？

你可能已经注意到，最近在开发者社区里，“DeepSeek Harness”和“Cordis”这两个词频繁出现在技术讨论帖、GitHub Issues 和内部技术分享会中。但很多人点开文档后第一反应是：这到底是个啥？它和 LangChain、Dify、CrewAI 这些耳熟能详的 Agent 框架有什么本质区别？为什么它不直接封装 LLM 调用，反而要设计一套叫 Cordis 的插件架构？我试过把 DeepSeek Harness 当成一个“带 UI 的本地 LLM 前端”来用，结果在安装第三个插件时卡在agent rpc error (-1): empty sid and service name上整整两小时——最后发现根本不是网络或模型加载问题，而是 Cordis 插件注册阶段的类型契约没对齐。这恰恰说明：Cordis 不是锦上添花的扩展机制，而是 DeepSeek Harness 的运行基石。它本质上是一套面向生产级 Agent 应用的类型驱动型插件编排系统，核心目标非常明确：让不同来源、不同语言（目前主推 TypeScript）、不同能力边界（工具调用、记忆管理、安全沙箱、跨进程通信）的 Agent 组件，能在统一契约下可验证、可组合、可热替换。它不解决“怎么调大模型”这种基础问题，而是解决“当你的 Agent 需要同时调用飞书 API、读取本地 SQLite、执行 Python 脚本、并受企业级 RBAC 控制时，如何保证整个流程不因某个插件升级而崩溃”。这解释了为什么所有热词都绕不开 TypeScript —— Cordis 的.d.ts声明文件不是辅助文档，而是插件间通信的唯一法律依据；也解释了为什么“deepseek harness 离线局域网使用”会被高频搜索——Cordis 架构天然支持无中心调度器的 Peer-to-Peer 插件发现，只要局域网内有服务节点广播其service name，其他节点就能按契约自动接入，根本不需要连公网。如果你正在评估 Agent 框架选型，别急着跑通 hello world，先问自己一个问题：你的 Agent 是否需要在未来三年内，持续集成来自不同团队、不同技术栈（Rust 写的加密模块、Python 写的数据清洗工具、Go 写的数据库连接池）的组件，并确保每次上线前能静态校验它们与主框架的兼容性？如果是，Cordis 就不是可选项，而是必选项。

2. Cordis 插件架构的核心设计逻辑与底层原理

2.1 为什么 Cordis 不是传统意义上的“插件系统”，而是一个“类型契约总线”？

市面上绝大多数插件系统（比如 VS Code 的 Extension API 或 Obsidian 的 Plugin API）遵循“宿主定义接口，插件实现接口”的单向契约模式。宿主暴露一组方法（如registerCommand,onDidOpenTextDocument），插件通过activate()函数注入具体实现。这种模式简单直接，但存在致命缺陷：契约变更即破坏性升级。一旦宿主更新了onDidOpenTextDocument的参数签名，所有未适配的插件立即失效。Cordis 彻底颠覆了这个范式。它的核心创新在于引入了Service Descriptor（服务描述符）作为双向契约载体。每个 Cordis 插件在发布时，必须提供一个严格遵循ServiceDescriptor类型定义的 JSON Schema 文件（通常存于dist/cordis-descriptor.json）。这个文件不描述“插件能做什么”，而是精确声明“插件对外暴露哪些服务端点、每个端点接受什么结构的输入、返回什么结构的输出、需要哪些前置依赖、是否需要沙箱隔离”。例如，一个飞书消息发送插件的 descriptor 可能包含：

{ "service": "lark.message.send", "version": "1.2.0", "input": { "type": "object", "properties": { "webhook_url": { "type": "string", "format": "uri" }, "content": { "type": "string" } }, "required": ["webhook_url", "content"] }, "output": { "type": "object", "properties": { "status": { "enum": ["success", "failed"] }, "error_code": { "type": "string" } } }, "dependencies": ["@cordis/core@^3.0.0"], "sandbox": true }

DeepSeek Harness 启动时，并非加载插件代码，而是先解析所有 descriptor 文件，构建一张服务拓扑图。这张图记录了lark.message.send@1.2.0服务由哪个插件提供、其输入/输出 schema 是什么、是否需要沙箱。当 Agent 工作流中需要调用该服务时，Harness 才根据拓扑图动态加载对应插件实例。这意味着：插件升级只要 descriptor 中的service和version不变，且input/outputschema 兼容（如新增可选字段），Harness 就能无缝接管——旧版工作流完全不受影响。我实测过一个场景：将飞书插件从 1.1.0 升级到 1.2.0，新版本增加了message_id字段用于去重，但 descriptor 中将其标记为"optional": true。所有旧版工作流继续正常运行，而新版工作流可以主动传入该字段。这种基于 Schema 的渐进式兼容，正是 Cordis 区别于其他框架的底层逻辑。它把“插件兼容性”这个运行时难题，提前到了构建时用 TypeScript 类型系统和 JSON Schema 双重校验。

2.2 Cordis 的三层架构：Runtime、Orchestrator 与 Descriptor Registry

Cordis 并非一个单体模块，而是由三个强耦合又职责分明的子系统构成，理解它们的协作关系是掌握其精髓的关键。

第一层：Cordis Runtime（运行时）
这是插件实际执行的沙箱环境。它不是一个简单的 Node.jsrequire()加载器，而是一个基于vm模块定制的受限执行上下文。每个插件都在独立的vm.Context中初始化，且 Runtime 会严格过滤掉全局对象（如process,globalThis）中所有危险属性。更重要的是，Runtime 提供了一组标准化的Host API，插件只能通过这些 API 与外部交互：

• host.invoke(serviceName, payload)：调用其他已注册服务（如调用sqlite.query）
• host.storage.get(key)/host.storage.set(key, value)：访问插件专属的键值存储（数据自动加密）
• host.logger.info(msg)：写入结构化日志（带插件 ID 和 trace ID）
• host.sandbox.exec(command, args)：在隔离子进程中执行外部命令（如python3 script.py）

提示：host.sandbox.exec是 Cordis 实现多语言支持的关键。当你看到 “基于 Rust 语言 AI Agent” 的热词时，背后就是 Cordis Runtime 启动了一个 Rust 编写的 CLI 工具，并通过标准输入/输出与之通信。插件本身仍是 TypeScript，但能力边界被彻底解放。

第二层：Cordis Orchestrator（编排器）
这是 Cordis 的“大脑”。它不参与具体业务逻辑，只负责三件事：

1. 服务发现：监听descriptor文件变化，实时更新服务拓扑图；
2. 契约验证：当 Agent 工作流定义中引用lark.message.send时，Orchestrator 会检查当前拓扑图中是否存在匹配service和兼容version的 descriptor，若不存在或 schema 不匹配，则在启动阶段就报错，而非等到运行时崩溃；
3. 调用路由：根据工作流中的服务调用链（如 A → B → C），生成最优执行路径。例如，若 B 和 C 都需要访问同一数据库连接池，Orchestrator 会复用连接而非创建两个独立实例。

第三层：Descriptor Registry（描述符注册中心）
这是 Cordis 的“黄页”。它并非一个中心化服务器，而是一个分布式共识系统。在离线局域网场景中，Registry 通过 UDP 广播service announcement包，每个节点既是发布者也是订阅者。广播包内容极简：

SID: 7a8b9c1d // 服务实例唯一ID SERVICE: lark.message.send VERSION: 1.2.0 ENDPOINT: http://192.168.1.100:3001/api/invoke

节点收到广播后，会向ENDPOINT发起一次轻量级健康检查（GET/health），成功则将其加入本地 Registry 缓存。这就是 “deepseek harness 可以在离线局域网使用” 的技术真相——没有中心服务器，只有节点间的 P2P 服务发现。我曾在无互联网的客户现场部署，5 台边缘设备开机后 3 秒内就完成了全部服务的自动注册与发现，整个过程零配置。

这三层架构共同构成了 Cordis 的韧性基础：Runtime 保障安全，Orchestrator 保障正确，Registry 保障可用。任何一层的故障都不会导致整个系统瘫痪，这正是它被设计用于企业级 Agent 应用的根本原因。

2.3 Cordis 与主流 Agent 框架的本质差异：不是“谁更好”，而是“解决什么问题”

把 Cordis 和 LangChain、Dify、CrewAI 放在一起比较，本身就是个伪命题。它们解决的问题域完全不同，就像拿“TCP/IP 协议栈”和“微信 App”做对比——前者是网络通信的底层基础设施，后者是上层应用。我们用一张表来划清边界：

举个真实案例：某金融客户需要构建一个“信贷审批 Agent”，它必须串联：1) 调用内部风控 API（Java 微服务）；2) 查询本地 SQLite 客户历史；3) 调用飞书 API 发送通知；4) 执行 Python 脚本进行反欺诈规则计算。用 LangChain 实现，意味着所有能力都要封装成Tool，而 Java 服务需额外开发 REST 接口，Python 脚本需用subprocess调用——这带来了巨大的运维负担和安全风险。用 Cordis，方案是：为 Java 服务编写一个轻量级 Cordis 插件（暴露risk.check服务），为 Python 脚本编写另一个插件（暴露fraud.detect服务），SQLite 和飞书已有官方插件。所有插件通过 descriptor 声明输入输出，Harness 自动完成服务发现、类型校验、沙箱执行。客户最终交付的不是一堆 Python 脚本，而是一份清晰的服务拓扑图和几份 descriptor 文件——这才是企业级落地的关键。

3. Cordis 插件开发全流程：从零开始构建一个可验证的插件

3.1 开发环境准备与项目脚手架初始化

Cordis 插件开发强制要求使用 TypeScript，且必须遵循严格的目录结构。不要试图用 JavaScript 直接写，因为 Cordis 的类型校验深度依赖.d.ts声明文件。我推荐使用官方脚手架@cordis/create-plugin，它比手动配置更可靠：

# 全局安装脚手架（需 Node.js 18+） npm install -g @cordis/create-plugin # 创建新插件项目（以“天气查询”为例） cordis-create-plugin weather-query --name "Weather Query Service" --service "weather.forecast" --version "1.0.0"

这条命令会生成一个标准项目结构：

weather-query/ ├── src/ │ ├── index.ts # 插件主入口，必须导出 activate() 函数 │ ├── types/ # 存放所有自定义类型定义 │ │ └── weather.d.ts # 与 descriptor input/output 对应的 TS 类型 │ └── services/ # 具体业务逻辑实现 │ └── forecast.ts ├── dist/ # 构建输出目录（含 descriptor.json） ├── cordis-descriptor.json # 核心契约文件，由脚手架生成初稿 ├── tsconfig.json # 严格配置，启用 --declaration 和 --noEmitOnError └── package.json

注意：cordis-descriptor.json是 Cordis 的“宪法”，任何修改都必须同步更新src/types/weather.d.ts中的类型定义，否则构建时tsc会报错。这是 Cordis 强制类型一致性的第一道防线。

3.2 编写核心契约：descriptor.json 与 .d.ts 类型文件的双向绑定

cordis-descriptor.json不是随意填写的配置文件，它是插件能力的唯一权威声明。我们以天气插件为例，逐步填充：

{ "service": "weather.forecast", "version": "1.0.0", "description": "Query 3-day weather forecast for a city", "input": { "type": "object", "properties": { "city": { "type": "string", "minLength": 2 }, "unit": { "type": "string", "enum": ["celsius", "fahrenheit"] } }, "required": ["city"] }, "output": { "type": "object", "properties": { "forecast": { "type": "array", "items": { "type": "object", "properties": { "date": { "type": "string", "format": "date" }, "temperature": { "type": "number" }, "condition": { "type": "string" } } } } } }, "dependencies": ["node-fetch@^3.3.0"], "sandbox": false, "timeout": 10000 }

现在，打开src/types/weather.d.ts，根据上述 JSON Schema 编写对应的 TypeScript 接口：

// src/types/weather.d.ts export interface WeatherInput { /** 城市名称，至少2个字符 */ city: string; /** 温度单位，默认celsius */ unit?: 'celsius' | 'fahrenheit'; } export interface WeatherForecastItem { /** 日期，ISO 格式 */ date: string; /** 温度数值 */ temperature: number; /** 天气状况 */ condition: string; } export interface WeatherOutput { /** 3天预报数组 */ forecast: WeatherForecastItem[]; } // 必须导出这两个类型，Cordis 构建工具会扫描它们 export type Input = WeatherInput; export type Output = WeatherOutput;

关键点来了：Cordis 的构建工具@cordis/build在npm run build时，会执行以下操作：

1. 读取cordis-descriptor.json中的input和output字段；
2. 解析src/types/weather.d.ts中的Input和Output类型；
3. 使用json-schema-to-typescript工具，将 JSON Schema 转换为 TS 类型；
4. 逐字段比对转换后的类型与weather.d.ts中的定义，任何不匹配（如city在 JSON 中是string，但在 TS 中被定义为number）都会导致构建失败。

这就是“双向绑定”的含义：descriptor 声明契约，TS 类型实现契约，构建工具强制校验二者一致。我曾见过团队成员为了赶进度，在 descriptor 中把temperature定义为integer，而在 TS 中写成number，结果构建通过但运行时报Type mismatch in output错误——因为integer在 JSON Schema 中是number的子集，但 Cordis 的校验是严格等价的。这个教训告诉我们：永远以 descriptor 为唯一真理源，TS 类型是它的精确镜像。

3.3 实现插件逻辑：在 Runtime 约束下编写安全可靠的代码

src/index.ts是插件的入口文件，它必须导出一个activate函数，该函数接收HostAPI并返回一个对象，其中包含invoke方法：

// src/index.ts import { HostAPI } from '@cordis/core'; import { Input, Output } from './types/weather'; import { fetchForecast } from './services/forecast'; export function activate(host: HostAPI) { return { // Cordis 要求的固定方法名 invoke: async (input: Input): Promise<Output> => { try { // 1. 输入校验：Cordis Runtime 不做此步，必须由插件自己完成 if (!input.city || input.city.length < 2) { throw new Error('City name must be at least 2 characters'); } // 2. 调用业务逻辑（注意：不能直接使用 fetch，需用 host.fetch） const result = await host.fetch('https://api.weather.com/v3/wx/forecast/daily/3day', { method: 'GET', headers: { 'X-API-Key': host.config.get('WEATHER_API_KEY') || '' }, searchParams: { 'geocode': await resolveGeocode(input.city), // 假设的地理编码函数 'units': input.unit || 'm' } }); // 3. 输出转换：必须严格符合 Output 类型定义 const data = await result.json(); return { forecast: data.forecasts.map((item: any) => ({ date: item.date, temperature: item.temperature, condition: item.condition })) }; } catch (error) { host.logger.error(`Weather query failed: ${error}`); throw error; } } }; } // 辅助函数：地理编码（必须放在 services/ 下，便于单元测试） async function resolveGeocode(city: string): Promise<string> { // 实际实现会调用第三方地理编码 API return '39.9042,116.4074'; // 北京坐标示例 }

这里有几个 Runtime 强制约束的要点：

• 禁止直接使用fetch或axios：必须通过host.fetch，因为 Runtime 需要统一管理网络请求的超时、重试、代理和审计日志；
• 禁止访问process.env：敏感配置（如 API Key）必须通过host.config.get('KEY_NAME')获取，该配置由 Harness 主进程注入，且在沙箱中不可见；
• 禁止console.log：所有日志必须走host.logger，以便集中收集和结构化分析；
• invoke方法必须是async且返回Promise<Output>：Cordis 会据此进行类型推断和运行时校验。

我建议在src/services/forecast.test.ts中为fetchForecast编写单元测试，使用 Jest 模拟host.fetch：

// src/services/forecast.test.ts import { fetchForecast } from './forecast'; describe('fetchForecast', () => { it('should return valid forecast data', async () => { // 模拟 host.fetch 返回预设响应 const mockHost = { fetch: jest.fn().mockResolvedValue({ json: jest.fn().mockResolvedValue({ forecasts: [ { date: '2023-10-01', temperature: 22, condition: 'Sunny' } ] }) }) }; const result = await fetchForecast(mockHost as any, { city: 'Beijing' }); expect(result).toEqual({ forecast: [ { date: '2023-10-01', temperature: 22, condition: 'Sunny' } ] }); }); });

3.4 构建、验证与部署：确保插件在 Harness 中 100% 可用

构建 Cordis 插件不是简单的tsc，而是运行专用命令：

# 安装构建依赖 npm install --save-dev @cordis/build # 执行构建（会触发 descriptor 与 TS 类型的双向校验） npm run build

@cordis/build会生成dist/目录，其中包含：

• index.js：编译后的插件代码；
• cordis-descriptor.json：与源码中完全一致的契约文件；
• types.d.ts：由构建工具生成的、与 descriptor 严格对应的声明文件（供其他插件引用）。

构建成功后，必须进行本地验证，这是避免线上事故的关键步骤：

# 启动一个临时 Harness 实例，仅加载本插件 npx @deepseek/harness@latest --plugin ./dist --debug # 在另一终端，用 curl 测试服务 curl -X POST http://localhost:3000/api/invoke \ -H "Content-Type: application/json" \ -d '{"service":"weather.forecast","input":{"city":"Shanghai","unit":"celsius"}}'

如果返回{"forecast":[...]}，说明插件通过了所有校验。此时，你可以将dist/目录整体打包为weather-query-1.0.0.zip，上传至 Harness 的插件仓库。Harness 在安装时会再次执行 descriptor 校验，并将types.d.ts注入全局类型系统，供其他插件在开发时引用。

实操心得：我踩过最大的坑是在package.json中错误地将@cordis/core设为dependencies而非peerDependencies。结果导致插件包体积暴增，且与 Harness 主进程的@cordis/core版本冲突。正确做法是：@cordis/core必须声明为peerDependencies，并在devDependencies中指定开发时的版本，这样构建工具才能确保插件与 Harness 运行时使用同一份核心库。

4. Cordis 插件架构的实战挑战与避坑指南

4.1 常见错误排查：从rpc error (-1)到empty sid的完整诊断链

agent rpc error (-1): empty sid and service name是 Cordis 新手最常遇到的错误，但它绝不是网络问题，而是服务注册失败的表象。完整的诊断链如下：

第一步：确认插件是否被 Harness 正确加载
查看 Harness 启动日志，搜索Loading plugin关键字。如果日志中没有出现你的插件名，说明dist/目录路径错误或cordis-descriptor.json格式非法（如 JSON 语法错误）。用jsonlint工具校验 descriptor 文件。

第二步：检查服务注册是否成功
启动 Harness 时添加--verbose参数，观察日志中是否有Registered service: weather.forecast@1.0.0。如果没有，大概率是 descriptor 中的service字段拼写错误（如写成weather.forecase），或version格式不符合 SemVer（如1.0而非1.0.0）。

第三步：验证服务发现机制
在 Harness 运行时，执行curl http://localhost:3000/api/services，返回一个 JSON 数组，列出所有已注册服务。如果weather.forecast不在其中，说明插件虽加载但注册失败。此时检查src/index.ts中的activate函数是否正确返回了{ invoke }对象，且invoke方法签名是否为async (input: Input) => Promise<Output>。

第四步：检查 SID（Service Instance ID）生成
sid是 Cordis 为每个服务实例生成的唯一 UUID。如果日志中出现empty sid，说明插件的activate函数执行异常，未能完成初始化。最常见的原因是host.config.get()获取不到必需的配置项，导致activate抛出异常。解决方案：在activate开头添加防御性检查：

export function activate(host: HostAPI) { // 关键：检查必需配置 const apiKey = host.config.get('WEATHER_API_KEY'); if (!apiKey) { throw new Error('WEATHER_API_KEY is required but not configured'); } return { invoke: async (input: Input) => { /* ... */ } }; }

第五步：终极验证——手动触发服务调用
如果以上步骤都通过，但仍报错，直接绕过 Agent 工作流，用 Harness 的调试 API 测试：

# 获取服务详情（确认 sid 存在） curl "http://localhost:3000/api/service?name=weather.forecast&version=1.0.0" # 手动调用（模拟 Agent 工作流） curl -X POST http://localhost:3000/api/invoke \ -H "Content-Type: application/json" \ -d '{ "service": "weather.forecast", "version": "1.0.0", "input": {"city": "Beijing"} }'

这个五步法覆盖了 95% 的rpc error (-1)场景。记住：Cordis 的错误信息看似晦涩，但每个字段都有明确指向，empty sid永远指向插件初始化失败，empty service name永远指向 descriptor 声明缺失。

4.2 TypeScript 类型陷阱：.d.ts文件的正确使用姿势

Cordis 对 TypeScript 的依赖远超一般项目，.d.ts文件的使用有三大陷阱：

陷阱一：declare module的滥用
很多开发者习惯在types/下创建declare module 'xxx'来补充第三方库类型。但在 Cordis 中，这是危险的。因为@cordis/build会扫描整个src/types/目录，将所有declare语句打包进types.d.ts。如果declare module 'node-fetch'中定义了fetch的全局类型，而 Harness 运行时的fetch是host.fetch，就会导致类型冲突。正确做法是：所有第三方类型必须通过npm install @types/xxx安装，且仅在src/services/的具体文件中import，绝不放在types/目录下。

陷阱二：any类型的传染性
当处理第三方 API 返回的未知 JSON 时，新手常写const data: any = await response.json()。这会导致data.forecasts的类型丢失，进而使return { forecast: data.forecasts }无法通过Output类型校验。必须使用类型守卫：

// 正确：定义精确的第三方响应类型 interface WeatherAPIResponse { forecasts: Array<{ date: string; temperature: number; condition: string; }>; } // 在 invoke 中 const data = await result.json() as WeatherAPIResponse; // 类型断言 return { forecast: data.forecasts.map(item => ({ date: item.date, temperature: item.temperature, condition: item.condition })) };

陷阱三：types.d.ts的引用方式错误
构建生成的dist/types.d.ts是供其他插件引用的，但你自己的插件代码绝不能/// <reference path="../dist/types.d.ts" />。这会造成循环依赖。正确方式是：在src/index.ts中直接import { Input, Output } from './types/weather'，让 TypeScript 编译器自然解析。

实操心得：我在一个大型项目中，曾因types/目录下存在一个空的index.d.ts文件，导致@cordis/build错误地将其打包进dist/types.d.ts，进而污染了整个平台的类型系统。最终解决方案是：在tsconfig.json中显式配置"include": ["src/**/*"]，并删除所有空的.d.ts文件。Cordis 的类型系统极其精密，任何微小的污染都会引发连锁反应。

4.3 生产环境最佳实践：安全、性能与可观测性

Cordis 插件一旦上线，就不再是玩具，而是生产系统的一部分。以下是经过多个客户项目验证的最佳实践：

安全加固：

• 最小权限原则：在cordis-descriptor.json中，sandbox字段默认为false，但只要插件涉及外部命令执行（如host.sandbox.exec），必须显式设为true。我曾见过一个插件因未开启沙箱，导致恶意输入触发了rm -rf /。
• 配置加密：所有敏感配置（API Keys）必须通过 Harness 的密钥管理服务注入，绝不在 descriptor 或代码中硬编码。Harness 启动时会自动解密并注入host.config。
• 输入白名单：对于city这类字符串输入，除了 descriptor 中的minLength，在invoke函数中还应添加正则校验if (!/^[a-zA-Z\s-]+$/.test(input.city)) throw new Error('Invalid city name')，防止路径遍历或命令注入。

性能优化：

• 连接池复用：如果插件需要频繁调用 HTTP API，不要在每次invoke中创建新host.fetch实例。利用host.storage缓存连接池：

  const pool = host.storage.get('http-pool') || new HttpPool(); host.storage.set('http-pool', pool);

• 冷启动加速：Cordis 插件默认是懒加载的。但对于高频服务（如sqlite.query），可在activate中预热：

  export function activate(host: HostAPI) { // 预热数据库连接 host.sandbox.exec('sqlite3', ['-version']).catch(() => {}); return { invoke: ... }; }

可观测性：

• 结构化日志：host.logger的每个方法都支持结构化字段：

  host.logger.info('Forecast retrieved', { city: input.city, duration_ms: Date.now() - start, cache_hit: true });

  这些字段会被自动注入到 ELK 或 Grafana 中，便于按city或duration_ms聚合分析。
• 自定义指标：通过host.metrics上报业务指标：

  host.metrics.observe('weather_forecast_duration_seconds', Date.now() - start, { city: input.city, unit: input.unit || 'celsius' } );

这些实践不是锦上添花，而是 Cordis 插件在生产环境中稳定运行的基石。每一次npm run build，都应该是一次安全审计和性能压测的起点。

5. Cordis 的未来演进与生态扩展可能性

Cordis 的设计哲学决定了它的演进路径不会是“增加更多开箱即用的功能”，而是“深化契约的表达力与执行的确定性”。从当前热词中，我们可以清晰看到三个明确的方向：

方向一：Descriptor Schema 的增强——从“能做什么”到“如何被信任”
现有的 descriptor 已能描述服务的输入输出，但尚未定义“可信度”。下一个版本将引入trust字段，允许插件声明其数据来源的可靠性等级：

"trust": { "source": "internal_api", // internal_api, third_party, user_input "certification": ["iso27001", "gdpr_compliant"], "data_retention_days": 30 }

Harness 将据此动态调整服务调用策略：对于source: "user_input"的服务，自动注入内容安全策略（CSP）；对于certification: ["iso27001"]的服务，允许在金融级工作流中使用。这直接回应了 “agent安全” 和 “agent记忆” 的热词需求——安全不是附加功能，而是服务契约的一部分。

方向二：跨语言插件 SDK 的标准化——Rust、Python 的第一公民地位
虽然 Cordis 运行时基于 Node.js，但host.sandbox.exec已为多语言铺平道路。官方即将发布cordis-rust-sdk和cordis-python-sdk，它们提供与 TypeScript SDK 完全一致的activate和invoke接口。Rust 插件将编译为 WASM 模块，在 Runtime 中安全执行；Python 插件将通过uv环境隔离。这意味着 “基于 Rust 语言 AI Agent” 不再是概念，而是 Cordis 生态的标准选项。我已在内部测试版中用 Rust 编写了加密插件，性能比 TypeScript 版本提升 3.2 倍。

方向三：离线自治能力的强化——真正的边缘智能
“deepseek harness 可以在离线局域网使用” 只是起点。Cordis 的下一步是让每个节点成为自治 Agent。通过集成libp2p，Registry 将支持服务状态的分布式共识。当主节点宕机时，其他节点能自动选举新的协调者，并基于本地缓存的 descriptor 继续提供服务。这使得 Cordis 不仅适用于企业内网，更能部署在卫星、无人机等