raphiki for Technology at Worldline

Posted on Sep 12

DeepSeek Harness: How DeepSeek Uses Cordis to Redefine Autonomous AI Agents

#deepseek #agentic #cordis #harness

Part 2 of the DeepSeek Harness: Kernel to Edge series: Exploring DeepSeek Harness (DSH), its 'everything-is-a-plugin' architecture, how it leverages Cordis under the hood, and how it compares to OpenCode, Pi, LangGraph, and CrewAI.

DeepSeek Harness: Kernel to Edge

This article is Part 2 of a three-part architectural and practical deep dive:

Part 1: Understanding Cordis: The TypeScript Framework Built for Hot-Swapping Everything (Microkernel primitives, spatiotemporal composability, reverse cleanup stacks, zero-leak lifecycles).

Part 2 (This Article): DeepSeek Harness: How DeepSeek Uses Cordis to Redefine Autonomous AI Agents (The meta-harness paradigm, Cordis as an agent kernel, comparing DSH to OpenCode and Pi).

Part 3: Running DeepSeek Harness on an 8GB GPU: Context Tuning, Presets, and Hardware Limits (Hands-on local deployment with Ollama, Ornith-1.5, VRAM arithmetic, minimal vs. standard presets, and TUI).

1. Introduction: Beyond the Prompt Chain

In Part 1, we explored Cordis, the lightweight TypeScript framework created by Shigma (Yifan Shi) that guarantees zero-downtime hot reloading and clean plugin lifecycles through revertible effects.

When developers first encountered Cordis, most viewed it primarily as the foundation for the Koishi chatbot ecosystem. In 2026, DeepSeek AI adopted it as the foundational engine for DeepSeek Harness (dsh).

DeepSeek chose not to build their agent framework in Python, avoiding both generic prompt-chaining libraries and opinionated role-playing engines.

Instead, DeepSeek hired Shigma, used Cordis as their microkernel, and published research grounding the approach ("A Programming Paradigm for Spatiotemporal Composability", arXiv:2608.25512).

The result is DeepSeek Harness (DSH): an open-source agent framework built on a distinct design rule:

"There is no privileged core. Every capability (the model adapter, the sandbox, the tools, the session log, and even the agent loop itself) is a replaceable plugin."

This article examines how DeepSeek Harness uses Cordis under the hood, how its architecture operates, and how it compares to other agent frameworks.

2. Why Call It a "Harness"? (Untangling the Terminology)

In the software industry, the word "harness" has become one of the most overloaded buzzwords in AI. Depending on who you talk to, a "harness" can mean a benchmark runner, a CLI chatbot, or a complex multi-agent framework.

To understand DeepSeek Harness, we need to untangle the three distinct categories of harnesses operating in the AI ecosystem today:

Category 1: Evaluation Harnesses (Benchmark Rigs):
- Examples: SWE-bench test runners, HumanEval fixtures.
- Purpose: A rigid testing scaffold designed to feed an issue to a model, run a test suite in a Docker container, and report a pass/fail grade. They are test rigs, not production application runtimes.
Category 2: Application / Coding Harnesses (Interactive Assistants):
- Examples: OpenCode, Pi Coding Agent, Claude Code.
- Purpose: Specialized developer tools designed for interactive, human-in-the-loop pair programming in a terminal or IDE. They come pre-configured with a fixed set of developer tools (read, edit, bash) running directly on your machine.
Category 3: Meta-Harnesses / Agent Operating Systems:
- Example: DeepSeek Harness (DSH).
- Purpose: An un-opinionated, headless microkernel. DSH does not presuppose what the agent is doing. It provides low-level operating system scaffolding (process isolation, append-only session streams, and reversible plugin lifecycles) upon which you can assemble an evaluation harness, an interactive coding assistant, or an autonomous research pipeline simply by changing a configuration profile.

Models like DeepSeek-R1 and DeepSeek-V3 require substantial host-level support to perform multi-step work:

Execution sandboxes: Docker containers, child processes, and isolated filesystems.
External interfaces: Web search, documentation scrapers, and external APIs.
Session persistence: Deterministic logging that records execution history without state drift.
Safety policies: Interceptors that validate commands before execution.

Most agent frameworks treat these capabilities as peripheral utilities. DeepSeek Harness treats the harness as an operating system kernel, providing the structural scaffolding required to run models autonomously without orphaned processes, memory leaks, or execution escapes.

3. Why DeepSeek Adopted Cordis

Why did DeepSeek choose Cordis over existing Python frameworks?

Limitations of Python Agent Frameworks

Most popular agent tools (LangChain, AutoGen, CrewAI) are written in Python. While Python is the standard for ML training and tensor operations, it introduces architectural friction when building long-lived agent runtimes:

Monotonic Memory: Python's garbage collector and global module cache make dynamic unloading difficult. If an agent spins up a background process or attaches an event listener, cleaning it up cleanly requires manual bookkeeping.
Heavy Startup Overhead: Python agent libraries often take seconds just to import their dependency trees.
Rigid Graphs: Tools like LangGraph model workflows as static directed graphs. If an agent discovers mid-flight that it needs a new tool, adding that tool dynamically usually requires recompiling the graph or restarting the agent.

How Cordis Addresses These Issues

Building on Cordis provides three concrete architectural advantages:

Fast Startup and Low Footprint: Running on Node.js and TypeScript, DSH boots in milliseconds with a lean baseline memory footprint (<50MB).
Guaranteed Teardown: When an agent launches a Docker container or a file watcher, Cordis wraps it in a Fiber. When the sub-task ends, Cordis guarantees teardown of all open handles and child processes.
Reactive Dependency Trees: If a task requires a Python environment, the Python tool only appears in the model's schema once a healthy sandbox service is active.

4. How DeepSeek Harness Works Under the Hood

Let's look at the six core architectural concepts that power DeepSeek Harness.

1. "There is No Core": The Pure Plugin Architecture

In DSH, you won't find a massive, hardcoded Agent class. Instead, every major subsystem is a Cordis plugin that extends Service:

ModelService (ctx.model): Handles token streaming, schema formatting, and provider connections (DeepSeek API, OpenAI, Anthropic, or local Ollama).
SandboxService (ctx.sandbox): Provides safe execution boundaries (isolated child processes, Docker containers, or WASM sandboxes).
SessionService (ctx.session): Manages the conversation history and transcript logs.
ToolRegistry (ctx.tools): Tracks available tools, validates schemas, and executes actions.
AgentLoop (ctx.agent): The turn-based execution cycle that prompts the model, receives tool calls, and handles responses.

Because these are all Cordis plugins, you can swap any of them independently. For instance, you can replace the default agent loop with a custom planner while keeping the existing tools and sandboxes intact. Even the user interface itself is just a plugin: DSH has no privileged GUI or CLI built into its runtime core.

2. Bundles and Profiles (`cordis.yml`)

DeepSeek Harness applications are composed declaratively using Bundles and Profiles.

Bundle: An npm package containing code, plugins, and schema configurations.
Profile: A YAML configuration file defining which bundles to load together.

Here is what a standard cordis.yml profile looks like:

# cordis.yml - DeepSeek Harness Composition
name: autonomous-coder

plugins:
  # 1. Model Provider Plugin
  '@deepseek-ai/dsh-model-deepseek':
    apiKey: env:DEEPSEEK_API_KEY
    model: deepseek-coder-v2

  # 2. Execution Sandbox Plugin
  '@deepseek-ai/dsh-sandbox-docker':
    image: 'node:22-alpine'
    timeoutMs: 30000

  # 3. Development Tools
  '@deepseek-ai/dsh-tool-filesystem':
    rootDirectory: './workspace'

  '@deepseek-ai/dsh-tool-bash':
    allowedCommands: ['git', 'npm', 'pnpm', 'test']

  # 4. Web UI Dashboard
  '@deepseek-ai/dsh-web-console':
    port: 3000

To run this agent stack with its web console:

npx @deepseek-ai/dsh web

Entry Profiles and Presets: Web, Headless, and Minimal

Because DSH is assembled from YAML profiles and runtime presets, switching the operational persona of your agent requires no code changes:

dsh web (or dsh --profile web): Boots the development stack with a local browser-based dashboard.
dsh --profile headless: Runs the agent in headless mode for CI/CD pipelines, automated testing, or background workers.
agent-presets: default: minimal: Activates a stripped-down two-tool composition, reducing system prompt token overhead and conserving system memory and GPU VRAM.

3. The Anatomy of a Custom DSH Plugin (15 Lines of TypeScript)

Writing your own tool or capability for DeepSeek Harness requires minimal code. Because it is a native Cordis plugin, you declare what dependencies you need (inject) and register your logic:

import { Context } from 'cordis';

export const name = 'project-stats';
export const inject = ['tools']; // Requires the ToolRegistry service

export function apply(ctx: Context) {
  // Register the tool; Cordis handles lifecycle and cleanup
  ctx.tools.register({
    name: 'get_project_stats',
    description: 'Returns file count and lines of code in current directory',
    execute: async () => {
      return 'Total files: 42 | Lines of code: 5,120';
    },
  });
}

Once written, you can declare it in your local cordis.yml profile or load it dynamically at runtime.

4. Session as an Append-Only Stream

Traditional frameworks treat chat history as a mutable array of { role, content } objects that developers manipulate directly.

DeepSeek Harness treats the Session as an immutable, append-only event stream.

Every user input, thinking block, model token, tool execution, and error is an immutable record in the stream.
Projections: The model's context window, the CLI output, and the Web UI are simply read-only "projections" rendered from this single source of truth.
Time Travel & Forking: Because the log is append-only, an agent can instantly fork a sub-agent to explore an alternative debugging hypothesis, test it, and discard it without corrupting the main conversation history.

5. Reversible Sandboxes and Dynamic Toolsets

In an extended autonomous task, an agent might need specialized capabilities only for a few minutes.

For example, when asked to analyze a dataset, the agent might need a Python data science environment (pandas, numpy, matplotlib). In traditional frameworks, that environment stays open forever.

In DeepSeek Harness, tools are mounted as Cordis Fibers:

import { Context } from 'cordis';

// A specialized tool plugin mounted dynamically
export function DataAnalysisToolPlugin(ctx: Context) {
  // Use ctx.effect to manage the sandbox lifecycle
  ctx.effect(() => {
    console.log('[Tool] Booting ephemeral Docker container for Python...');
    const container = ctx.sandbox.createContainer({ image: 'python:3.11-slim' });

    // Register the tool
    const unregister = ctx.tools.register({
      name: 'run_python_script',
      description: 'Executes Python data analysis code',
      execute: async ({ code }) => container.exec(code),
    });

    // Cleanup: When the agent unloads this plugin, the container is destroyed!
    return async () => {
      console.log('[Tool] Tearing down ephemeral container...');
      unregister();
      await container.destroy();
    };
  });
}

When the data analysis step is complete, the agent or harness calls fiber.dispose(). Cordis instantly kills the container, frees the RAM, and removes the tool from the model's schema.

6. Waterfall Control Flow & Guardrails

How does DeepSeek Harness prevent an autonomous agent from running destructive commands (like rm -rf / or leaking API keys)?

It uses Cordis's waterfall event pattern:

Any plugin can hook into agent/pre-step or agent/request. If a security plugin detects an unsafe command, it can rewrite it, request user confirmation, or bail out early before the sandbox is ever touched.

5. The True Meta-Harness: An Exploding Plugin Ecosystem

Why does DeepSeek Harness deserve the title of a true meta-harness?

Turnkey coding agents (such as OpenCode or Claude Code) ship as monolithic binaries with predetermined tools, fixed workflows, and rigid interfaces. If you want a different terminal layout, a custom vision pipeline, or specialized memory management, you have to submit a feature request or fork the codebase.

In DSH, the harness is not a closed application; it is an open substrate. Because the microkernel has "no core" and treats every capability as an unprivileged Cordis plugin, developers can reshape every layer of the agent experience.

Even the User Interface is a Plugin (Web UI vs. TUIs)

A textbook example of this architectural neutrality is the user interface itself:

The Web UI is Just a Plugin: When you run dsh web, DSH boots an HTTP server and mounts a frontend plugin bundle (@deepseek-ai/dsh-web-console or dsh-web-ui). The harness core neither knows nor cares that a web browser is rendering the output.
Terminal UIs (TUIs) on Demand: If you prefer staying strictly inside your terminal to avoid context switching, you can completely bypass the web dashboard. Community plugins like dsh-TUI transform DSH into a full-screen, keyboard-driven terminal coding agent reminiscent of Claude Code, complete with streaming token output and interactive approval prompts.
Workbench Enhancements: For developers using the browser console, plugins like DSH-better-sidebar enhance the default layout by docking file trees, Git status, terminal sessions, and live browser previews directly alongside the chat stream.

Thousands of Plugins and Rising Community Marketplaces

This native extensibility has catalyzed a rapidly expanding community ecosystem. In only a few months, thousands of open-source plugins have been authored by developers worldwide, giving rise to dedicated community directories and marketplaces:

deepseekplugin.com: A centralized directory cataloging community-built DSH plugins across diverse functional categories.
dsh-plugin.org / dsh-plugins.org: Open documentation and discovery hubs for exploring plugin architectures, configuration snippets, and trending add-ons.

Real-World Plugin Innovations: Beyond Simple Coding Tools

As analyzed in Composio's roundup of top DeepSeek Harness plugins, community developers are extending DSH far beyond basic file reading and bash execution:

Multimodal Vision Toolkits (ModLens, dsh-vision-toolkit): Give text-only models visual perception. These plugins provide structured OCR, visual grounding, layout analysis, UI reconstruction from screenshots, and pixel-by-pixel comparisons.
Generative UI (dsh-genui): Allows the agent to render more than 30 interactive user interface widgets (cards, responsive data tables, forms, charts) directly inside conversational responses.
Ergonomic Workspace Mentions (dsh-at-file): Brings Codex-style @file and @folder mentions into the composer, letting developers inject file contents and directory context without manual copy-pasting.
Multi-Tiered Memory (dsh-mnemon): Solves agent amnesia across turns by providing three distinct memory layers: Runtime Memory for turn-by-turn preferences, Document Memory for repository conventions, and long-term knowledge retention.
In-Harness Discovery & Self-Installation (dsh-market, dsh-find-plugin): Brings the marketplace directly into DSH. dsh-market embeds a visual plugin market into the Settings UI, while dsh-find-plugin equips the agent itself with a tool to search GitHub for plugins on the fly and self-install capabilities during an active run.

6. Positioning DSH: Comparing Harnesses Across the AI Landscape

To truly understand where DeepSeek Harness fits, we have to look at the broader AI landscape. Developers often conflate two very different layers of software:

High-Level Agent Frameworks (LangGraph, CrewAI, AutoGen): Libraries designed for prompt chains, multi-agent debates, and graph state machines.
Dedicated Coding Agent Harnesses (OpenCode, Pi Coding Agent, Claude Code): Specialized developer tools designed to run in your terminal or IDE to edit code.

DeepSeek Harness bridges both worlds by operating as a Meta-Harness (an Agent Operating System). Let's break down how it compares to both categories.

Layer A: DSH vs. General Agent Frameworks (LangGraph, CrewAI)

Most general agent frameworks are written in Python and focus on orchestrating conversations and workflow graphs:

LangGraph (Circuits & Graphs): Models agents as fixed directed cyclic graphs (nodes, edges, and state channels). While powerful for predictable workflows, dynamic changes are difficult: adding a new tool or modifying execution mid-flight requires recompiling the graph or restarting the agent.
CrewAI / AutoGen (Personas & Roleplay): Models agents as personas with roles, backstories, and conversational message passing. Great for creative simulations, but they lack low-level systems control over processes, memory reclamation, and execution sandboxes.
DeepSeek Harness (An Operating System Microkernel): Instead of modeling agents as circuits or personas, DSH models agents as an operating system. The Cordis microkernel provides the core primitives (event bus, service registry, fibers). Models, tools, sandboxes, and the agent loop itself are drivers that plug into that OS.

Layer B: DSH vs. Dedicated Coding Harnesses (OpenCode, Pi)

If you are a software engineer, you are likely more familiar with specialized coding agent harnesses like OpenCode or Pi Coding Agent:

OpenCode (The Model-Agnostic Developer Companion):
- Developed by the SST team (anomalyco/opencode) in TypeScript/Bun, OpenCode provides a polished developer experience with terminal, desktop, and web interfaces.
- It ships with a pre-tuned suite of developer tools (read, write, edit, glob, grep, bash).
- Where it excels: Interactive, human-in-the-loop coding sessions on your local machine.
- The Architectural Difference: OpenCode is a turnkey coding tool. Its tool registry, session loop, and interaction models are tailored to developer workflows. Tools run directly on your host environment, and the toolset is static per session.
Pi Coding Agent (The Minimalist Terminal Agent):
- Created by Mario Zechner, Pi (@earendil-works/pi-coding-agent) is a lightweight terminal coding agent designed around minimalism and extensibility.
- It separates concerns into clean packages (unified LLM API, agent runtime, terminal UI).
- The Architectural Difference: Pi is designed to do one thing well: serve as an extensible terminal coding companion for an individual engineer.
DeepSeek Harness (The Reversible Meta-Harness):
- DSH is not hardcoded as a coding assistant. Coding tools are merely plugins.
- By stacking different YAML profiles (cordis.yml), DSH can function as a terminal coding agent (similar to OpenCode or Pi), an automated benchmark runner, a web research crawler, or a security audit pipeline.
- Dynamic Ephemeral Isolation: Rather than running all commands directly on your host machine, DSH is built for unattended autonomous execution. It can spin up an ephemeral container for a sub-task, inject tools into the agent context, execute the work, and tear down the environment without leaving orphaned processes or open ports.

Under the Hood: How Their Plugin Systems Actually Differ

To see why DSH behaves differently in runtime management, compare how you extend each harness:

Pi Coding Agent (Boot-Time Extension Hooks):
- Mechanism: You export a function or object that registers custom tools or commands into Pi's registry at startup.
- Lifecycle: Static and persistent. Extensions live for the entire duration of the CLI session.
- Best for: Personal CLI shortcuts and custom prompt extensions.
OpenCode (Config-Driven Tools & External MCP Servers):
- Mechanism: Tools are declared in configuration or connected via the Model Context Protocol (MCP).
- Lifecycle: Process-isolated client-server architecture. Tools typically run as external background programs communicating over stdio or HTTP.
- Best for: Reusing standardized enterprise tools across multiple IDEs and agents without rewriting tool code.
DeepSeek Harness (In-Process, Reactive Cordis Fibers):
- Mechanism: Plugins mount directly into the in-process Context Tree via Cordis. They provide core services (ctx.provide), declare dependencies (inject), and register self-cleaning side effects (ctx.effect).
- Lifecycle: Dynamic, reactive, and reversible. A plugin can be hot-swapped, suspended, or unloaded during execution. Cordis guarantees that any socket, timer, or container created by that plugin is destroyed upon disposal.
- Best for: Autonomous agents that dynamically adapt their environment, spin up temporary sandboxes, or synthesize new tools on the fly.

The Comprehensive Architectural Matrix

Dimension	General Frameworks (LangGraph, CrewAI)	Turnkey Coding Harnesses (OpenCode, Pi)	Meta-Harness (DeepSeek Harness)
Primary Goal	Multi-agent chains & graph workflows	Interactive developer coding assistant	Headless, autonomous agent operating system
Language & Runtime	Python (Heavy import overhead)	TypeScript / Bun (Fast, developer-friendly)	TypeScript / Node.js (Lightweight <50ms)
Architecture	Static Graphs or Multi-Agent Chats	Monolithic / Modular Coding Loop	Pure Cordis Microkernel (Zero privileged core)
Plugin Mechanism	Hardcoded in Python state schema	Boot-time extension hooks / external MCP	In-process reactive Cordis Fibers (with auto-cleanup)
Execution Sandboxing	Manual script execution / External Docker	Direct execution on developer's host machine	Built-in Reversible Fibers (Docker, WASM, Process)
Session Model	Chat history lists / state dictionaries	Interactive session transcripts	Immutable append-only stream with projections
Dynamic Self-Evolution	❌ No (requires graph rebuild)	❌ No (fixed tool schema)	Yes ("Creation Mode" via runtime plugins)

In Short:

Use LangGraph or CrewAI when you want to design a multi-persona conversational workflow or a fixed graph pipeline in Python.
Use OpenCode or Pi when you want a fast, interactive AI pair programmer in your terminal to help you build software.
Use DeepSeek Harness when you need an unattended agent runtime that dynamically manages tools, isolates sandboxes, runs extended tasks without resource leaks, and supports runtime plugin extension.

7. Dynamic Tool Generation at Runtime ("Creation Mode")

One notable capability enabled by Cordis is dynamic plugin generation at runtime, often called "Creation Mode".

Because Cordis allows modules to be loaded and unloaded at runtime, an agent can dynamically extend its own abilities:

Problem: An agent is tasked with parsing a proprietary binary format. It currently has no tool for this.
Code Generation: The agent writes a custom TypeScript parser plugin and saves it to its local directory.
Dynamic Mounting: The agent uses Cordis to hot-load its newly written plugin into its own context:

   await ctx.plugin(NewlyWrittenPlugin);

Execution & Verification: The agent now sees the new tool in its schema, executes it, and inspects the result.
Resolution: If the tool is flawed, it fixes the code and hot-reloads it. Once the task is solved, it can either commit the plugin to its permanent bundle or dispose of it cleanly.

Instead of relying solely on a fixed set of pre-bundled tools, the agent can synthesize, test, and safely tear down its own execution utilities as new requirements arise during a task.

8. Conclusion

By building on Cordis, DeepSeek Harness avoids the resource leaks and rigid orchestration common in traditional agent runtimes. Grounded in both practical experience from the Koishi ecosystem and research into spatiotemporal composability, DSH demonstrates a disciplined foundation for long-running autonomous tasks:

Modular components: There is no privileged core; tools, sandboxes, and agent loops can be swapped independently.
Reversible side effects: Sandboxes and resource handles are tracked in fibers and cleaned up automatically upon disposal.
Low operational footprint: Fast startup time with minimal idle memory consumption.

Coming Next in Part 3: Running DeepSeek Harness on an 8GB GPU

With Cordis covered in Part 1 and DeepSeek Harness's architecture mapped here in Part 2, the next installment moves to practical implementation.

In Part 3: Running DeepSeek Harness on an 8GB GPU, we configure an autonomous coding agent running locally on a laptop equipped with an 8GB RTX 4070 GPU:

Minimal Preset: Configuring DSH with the minimal agent preset to streamline tool schemas, compress prompt overhead, and maximize available context.
Local Inference: Connecting DSH to Ollama running quantized coding models such as Qwen2.5-Coder or Ornith-1.5.
VRAM and Context Tuning: Setting context limits and parameter budgets so the agent can inspect and edit multi-file projects without running out of GPU memory or truncating context.

References & Links

DeepSeek Harness GitHub Repository: github.com/deepseek-ai/deepseek-harness
DeepSeek Harness Documentation & Cordis Primer: deepseek-harness.github.io/deepseek-harness
Community Plugin Directories: deepseekplugin.com | dsh-plugins.org | dsh-plugin.org
Composio Best DSH Plugins Guide: composio.dev/content/best-deepseek-harness-plugins
Theoretical Research Paper: Shi, Y., Zhang, W., & Cui, T. A Programming Paradigm for Spatiotemporal Composability (arXiv:2608.25512)
OpenCode Repository: github.com/anomalyco/opencode
Pi Coding Agent: pi.dev
Part 1 of this Series: Understanding Cordis: The TypeScript Framework Built for Hot-Swapping Everything
Part 3 of this Series: Running DeepSeek Harness on an 8GB GPU: Context Tuning, Presets, and Hardware Limits

DEV Community

DeepSeek Harness: How DeepSeek Uses Cordis to Redefine Autonomous AI Agents

1. Introduction: Beyond the Prompt Chain

2. Why Call It a "Harness"? (Untangling the Terminology)

3. Why DeepSeek Adopted Cordis

Limitations of Python Agent Frameworks

How Cordis Addresses These Issues

4. How DeepSeek Harness Works Under the Hood

1. "There is No Core": The Pure Plugin Architecture

2. Bundles and Profiles (`cordis.yml`)

Entry Profiles and Presets: Web, Headless, and Minimal

3. The Anatomy of a Custom DSH Plugin (15 Lines of TypeScript)

4. Session as an Append-Only Stream

5. Reversible Sandboxes and Dynamic Toolsets

6. Waterfall Control Flow & Guardrails

5. The True Meta-Harness: An Exploding Plugin Ecosystem

Even the User Interface is a Plugin (Web UI vs. TUIs)

Thousands of Plugins and Rising Community Marketplaces

Real-World Plugin Innovations: Beyond Simple Coding Tools

6. Positioning DSH: Comparing Harnesses Across the AI Landscape

Layer A: DSH vs. General Agent Frameworks (LangGraph, CrewAI)

Layer B: DSH vs. Dedicated Coding Harnesses (OpenCode, Pi)

Under the Hood: How Their Plugin Systems Actually Differ

The Comprehensive Architectural Matrix

In Short:

7. Dynamic Tool Generation at Runtime ("Creation Mode")

8. Conclusion

Coming Next in Part 3: Running DeepSeek Harness on an 8GB GPU

References & Links

Top comments (0)

1. Introduction: Beyond the Prompt Chain

2. Why Call It a "Harness"? (Untangling the Terminology)

3. Why DeepSeek Adopted Cordis

Limitations of Python Agent Frameworks

How Cordis Addresses These Issues

4. How DeepSeek Harness Works Under the Hood

1. "There is No Core": The Pure Plugin Architecture

2. Bundles and Profiles (cordis.yml)

Entry Profiles and Presets: Web, Headless, and Minimal

3. The Anatomy of a Custom DSH Plugin (15 Lines of TypeScript)

4. Session as an Append-Only Stream

5. Reversible Sandboxes and Dynamic Toolsets

6. Waterfall Control Flow & Guardrails

5. The True Meta-Harness: An Exploding Plugin Ecosystem

Even the User Interface is a Plugin (Web UI vs. TUIs)

Thousands of Plugins and Rising Community Marketplaces

Real-World Plugin Innovations: Beyond Simple Coding Tools

6. Positioning DSH: Comparing Harnesses Across the AI Landscape

Layer A: DSH vs. General Agent Frameworks (LangGraph, CrewAI)

Layer B: DSH vs. Dedicated Coding Harnesses (OpenCode, Pi)

Under the Hood: How Their Plugin Systems Actually Differ

The Comprehensive Architectural Matrix

In Short:

7. Dynamic Tool Generation at Runtime ("Creation Mode")

8. Conclusion

Coming Next in Part 3: Running DeepSeek Harness on an 8GB GPU

References & Links

2. Bundles and Profiles (`cordis.yml`)