Building Private AI Coding Platforms: Comparing Pi, DSH & Codex Harness Extensibility

Why These Three Harnesses?

Enterprises need custom AI coding agents that integrate internal systems, context loading, security policies, and infrastructure. Building on an open-source harness with strong extensibility is more practical than hand-coding from scratch. The article selects Pi, DeepSeek Harness (DSH), and Codex Harness because all are open-source, provide reusable cores (session, loop, tools, context), offer real extension interfaces beyond prompt tweaking, and support diverse integration via SDK/RPC.

Pi: Small Kernel, Large Extension

Pi-Coding-Agent adopts a minimalist core—only basic read/write tools, no MCP, subagents, plan mode, or todos. Its philosophy: perfect the core engine, let users extend everything else via a centralized ExtensionAPI. Extensions are written in TypeScript and can register tools, commands, event hooks, flags, and customize TUI components.

Example Pi extension:

export default function(pi: ExtensionAPI) {
  pi.registerTool(queryCustomer); // extend tool
  pi.on("tool_call", auditBeforeCall); // event hook
  pi.setActiveTools(activeTools); // control enabled tools
  pi.registerCommand(planCommand); // extend command
  pi.registerFlag(sandboxFlag); // extend launch flag
}

Pi also provides RPC and SDK for embedding into web apps or VS Code plugins. The TUI can be replaced or augmented via a TUI SDK.

DeepSeek Harness (DSH): Everything Is a Plugin

DSH uses the Cordis plugin system where every capability—model adapters, tool registry, session logging, filesystem, shell, sandbox, and even the core Agent Loop—is a plugin. Cordis kernel only manages loading, unloading, and dependency resolution via a shared ctx object (e.g., ctx.tools, ctx.llm).

Analogy: Cordis is a LEGO baseplate; models, tools, and loops are bricks; ctx is the universal connector.

Example DSH plugin registering a tool:

import type { Context } from '@deepseek-ai/cordis'
import { defineTool } from '@deepseek-ai/dsh-tools'

export const name = 'tool-hello'
export const inject = ['tools']

export function apply(ctx: Context) {
  ctx.tools.register(defineTool({
    name: 'hello',
    description: '向指定的人问好',
    parameters: ...,
    output: ...,
    async execute({ name }) {...},
  }))
}

The inject array declares dependencies (here the tools registry service), enabling Cordis to manage activation order. Plugins can be swapped, including the Agent Loop itself, allowing assembly of entirely different agent systems.

Codex Harness: Stable Kernel, Standard Extensions

OpenAI's Codex Harness is a mature Rust kernel handling agent loop, streaming events, context management, tool orchestration, session recovery, sandbox, permissions, and approvals. It offers three integration modes: Codex exec (CLI/CI), Codex SDK (programmatic task control), and App Server (deep GUI/IDE embedding via stdio).

Extension follows established standards rather than a deep API:

AGENTS.md : inject project rules, domain knowledge, top-level constraints

Skills : package reusable SOPs, knowledge, scripts

Hooks : run custom logic at tool-call, session-end, etc.

MCP : connect enterprise data, tools, business operations

Plugin : bundle Skills, MCP, Hooks into distributable packages

Modifying the Rust kernel is possible but incurs high maintenance cost. Codex favors stability and governance (sandbox, approvals, trust) over deep customization.

Comparison & Selection Guide

The article summarizes three distinct philosophies:

Pi : deeply modify an existing agent factory; keep the kernel, extend periphery via ExtensionAPI. Best for teams wanting a ready-to-use TUI/VS Code agent with heavy tool/command/event customization.

DSH : assemble a modular factory from plugins; replace any component including the loop. Best for enterprises needing highly autonomous, swappable agent platforms across local, container, cloud, and on-prem environments.

Codex : attach new capabilities to a mature, enterprise-grade harness via standards (MCP, Hooks, Skills). Best for teams prioritizing rapid integration of enterprise knowledge/tools with strong governance and minimal development.

Enterprises need not pick one harness for all scenarios—developers may use Pi/DSH for coding while office agents use Codex via MCP, and complex workflows may orchestrate multiple agents via LangGraph.