A New Paradigm for Agent Engineering: Everything as Plugins

DeepSeek Harness offers a fresh construction paradigm for agents, positioning it as a more innovative alternative to the LangChain approach, which was originally designed to lower the complexity of agent development.

01 What is Plug‑in‑based Architecture?

In software, plug‑ins are common extensibility mechanisms (e.g., browser extensions, mobile app store packages). They provide four key properties:

Decoupling: each plug‑in is a self‑contained functional block that does not require changes to the host code.

Pluggability: plug‑ins can be added or removed without affecting the underlying software.

Replaceability: the same interface can be swapped for a better implementation, such as a different translation plug‑in.

Standardization: all plug‑ins follow a shared interface contract, ensuring compatibility across contributors.

Within DeepSeek Harness, “everything is a plug‑in” means that the model connector, tool invoker, session manager, memory, UI, and even the agent’s main loop are all designed as interchangeable components, recorded in a transparent event log.

02 How Does This Differ from the LangChain Paradigm?

LangChain, LlamaIndex, AutoGen, CrewAI and similar frameworks abstract away low‑level details (chain, agent, tool, memory, retriever) to simplify development. While this reduces the entry barrier, it also hides the decision‑making process of the model, making it harder to understand why an agent chose a particular tool or generated a specific response.

DeepSeek Harness tackles the “double‑black‑box” problem (model + framework) by exposing every step—model input/output, tool calls, context injection, and loop decisions—in a replayable event stream. This transparency enables precise debugging of hallucinations, infinite loops, tool‑call chaos, or cost spikes.

03 What Plug‑ins Does DeepSeek Harness Include?

The architecture is layered, with each layer adding or overriding plug‑ins:

Bundle (Combination Package) Layer: an npm package that declares which plug‑ins (model adapters, tools, persistence, sandbox, settings, etc.) to load via cordis.patch.yml. Example bundles are dsh-base (core capabilities) and dsh-web-app (adds a web UI).

Profile (Configuration) Layer: named configuration files stored under ~/.dsh/profiles/<name>. A profile lists bundles in order and can provide its own patch file to customize or replace bundle entries.

User Patch Layer: two levels—profile‑specific cordis.patch.yml (higher priority than bundles) and a global $DSH_HOME/cordis.patch.yml that applies to all profiles.

Command‑line Overlay Layer: the --patch flag adds a temporary, highest‑priority patch at runtime (e.g., dsh web --patch ./my-patch.yml).

The final plug‑in set is built by merging these layers in order: Bundle → Profile patch → Home patch → --patch. The resulting configuration tree can be inspected with dsh --profile web --dump-config.

04 How to Use and Contribute Plug‑ins

Typical workflows include:

Use an official bundle directly: npx @deepseek-ai/dsh web or dsh --profile headless.

Inspect the active plug‑in tree: dsh --profile web --dump-config.

Install community or custom bundles: dsh plugin --profile web add <npm‑package-or‑path>.

Create a local patch file and apply it with --patch.

Write plug‑ins in code. A plug‑in exports a name, optional inject array for dependencies, and an apply(ctx) function that registers tools, listeners, or services. Example template:

import type { Context } from '@deepseek-ai/cordis'
export const name = 'my-plugin'
export const inject = ['tools'] // optional dependencies
export function apply(ctx: Context) {
  // register tools, listen to events, provide services, etc.
  ctx.tools.register(...)
}

The framework automatically cleans up resources when a plug‑in is removed.

05 Benefits for Effect and Cost Optimization

Because DeepSeek Harness records every token consumption and makes each component replaceable, developers can:

Effect Optimization: swap loop strategies, context injection logic, tool pipelines, or sandbox policies. Minimal mode is useful for benchmarking models, while creative mode enables rapid experimentation with new compositions. Full trace replay reveals the exact cause of failures.

Cost Optimization: session logs expose token usage per step, allowing adjustments to prompt assembly, tool schema ordering, or cache friendliness. Switching to lighter‑weight plug‑ins or model‑specific providers can dramatically improve success rates and reduce per‑token cost.

Continuous Iteration: plug‑ins are reversible, supporting hot‑swap during development. Engineers can treat architectural changes like hyper‑parameter tuning—replace a sandbox, modify an event interceptor, or re‑bundle components and instantly observe impact.

When the application architecture no longer bottlenecks performance, the true potential of intelligent agents is unlocked. Mastering this fine‑grained, plug‑in‑centric foundation empowers developers to fine‑tune agent experience and economics with unprecedented precision.