DeepSeek Harness GitHub Project: Everything Is a Plugin

DeepSeek Harness GitHub Project: What Is It?

DeepSeek Harness is an open-source agent harness developed by DeepSeek AI. Its central architectural idea is simple:

Everything is a plugin.

The project is powered by Cordis, a framework designed around composable services and extensions. Rather than building an AI agent as one large application, DeepSeek Harness separates capabilities into modular components that can be replaced, extended or composed.

The repository is currently in developer preview and is being iterated rapidly, with the maintainers explicitly warning that compatibility-breaking changes can occur.

What Is an Agent Harness?

An AI agent needs more than an LLM.

A practical agent typically requires:

Sessions
Prompt management
Model providers
Tools
File and shell access
Memory or persistent state
Skills
Subagents
Scheduling
User feedback
APIs
Interfaces

An agent harness provides the infrastructure connecting these pieces.

DeepSeek Harness approaches this through a modular plugin architecture rather than putting every capability directly into the core agent.

Everything Is a Plugin

The defining idea behind DeepSeek Harness is its plugin-oriented architecture.

The repository organizes functionality into capability families such as:

Core agent loop
Sessions
Tools
LLM providers
Subprocess execution
Skills
Scheduling
Feedback
Identity
Workspaces
APIs
Subagents

The package architecture separates service definitions from implementations, allowing components to evolve independently.

This means developers can work with a specific part of the system without having to rebuild the entire agent.

Core Architecture

The packages/core area contains several important pieces of the agent spine.

These include:

Sessions

The session subsystem maintains the agent's history as an append-only event log.

System Prompts

System-prompt components assemble the instructions and context supplied to the model.

Tools

The tool subsystem provides the registry and guarded execution pipeline through which agent tools are dispatched.

Agent

The agent package provides the main Agent abstraction and its registry/events.

Agent Loop

The agent-loop package provides the default driver responsible for creating agents and running their turn/step lifecycle.

LLM Provider Architecture

DeepSeek Harness also separates the LLM capability family from the rest of the system.

This allows model-provider adapters to be handled independently from the core agent infrastructure. The package structure identifies llm/ as the LLM capability family containing the abstract service and provider adapters.

This is useful for an agent framework because the model layer can change without forcing every other component to be rewritten.

Skills System

DeepSeek Harness includes a dedicated Skills subsystem.

Skills are reusable instructions that can be discovered and loaded when required.

The current architecture includes:

Skill registry
Filesystem-based skill discovery
Skill catalogs
Model-facing skill loader
Office-related workflows
Direct skill invocation

The documentation describes skills as reusable task instructions that can be loaded only when needed.

This creates a workflow where the model doesn't necessarily need every instruction loaded into its context from the beginning.

Subagents

DeepSeek Harness also provides infrastructure for running additional agents.

This makes it possible to construct workflows where one agent can delegate work to another agent or where multiple agent sessions can operate independently.

The architecture includes dedicated packages for agent-to-agent and ACP-related workflows.

A simplified workflow can look like:

Main Agent

↓

Task Delegation

↓

Subagent

↓

Tool Execution

↓

Result

↓

Main Agent

This architecture is particularly relevant to multi-agent AI applications.

Agent Client Protocol

One of the more interesting components is its Agent Client Protocol (ACP) support.

The ACP package allows programs and automation systems to run persistent DeepSeek Harness agents over JSON-RPC via standard input/output.

Clients can:

Create sessions
List sessions
Resume sessions
Close sessions
Attach MCP servers
Select models
Send text prompts
Send image prompts
Receive updates
Respond to permission prompts
Cancel work

The ACP server is designed specifically for programmatic automation and does not require a human to remain in the loop.

Python SDK

DeepSeek Harness also includes a Python SDK for driving the harness as a subprocess.

The SDK communicates with the bundled runtime through newline-delimited JSON-RPC over standard I/O.

Installation currently uses:

python -m pip install deepseek-harness-sdk

A basic Python workflow can then create a DeepSeekHarness instance with an explicitly selected Harness home, working directory, provider and model.

This makes the harness usable from Python-based automation and applications rather than only through its own UI.

Persistent Workspaces

DeepSeek Harness also has a workspace subsystem.

The workspace family allows applications to maintain an ordered collection of named projects and group sessions by directory.

Users can browse projects and sessions, hide sessions from project grouping and remove project records without deleting the underlying folder or session history.

For developers working across multiple repositories, this provides a structured project/session layer around agent activity.

Web UI

DeepSeek Harness provides a local Web UI.

The quickest documented method is:

npx @deepseek-ai/dsh web

The local server runs at:

http://127.0.0.1:3080

By default, the local launch can open the interface in the system browser. The --no-open option can be used when the browser should not be opened automatically.

Running from Source

Developers who want to work directly with the repository can clone it and build it locally:

git clone https://github.com/deepseek-ai/deepseek-harness.git

cd deepseek-harness

pnpm install

pnpm run build

pnpm dsh web

The repository documentation notes that pnpm run build prepares the required artifacts, while pnpm dsh web runs the Web UI using those built artifacts.

DeepSeek Harness and MCP

The project also has infrastructure for connecting tools and external capabilities.

Its ACP implementation, for example, allows clients to attach standard MCP servers to persistent agent sessions.

This makes the architecture relevant to developers building agent systems around:

LLM + MCP + Tools + Skills + Subagents + Persistent Sessions

Example Agent Architecture

A simplified DeepSeek Harness workflow can be understood as:

                AI Model
                   |
             Agent Loop
                   |
        +----------+----------+
        |          |          |
      Tools      Skills    Subagents
        |          |          |
     MCP /      Reusable    Other
     APIs       Tasks       Agents
        |          |          |
        +----------+----------+
                   |
              Session Log
                   |
             Workspace / UI

The important part is that these components are not treated as one inseparable block. They are organized into modular capability families.

Why the Plugin Architecture Matters

Traditional AI applications often grow into large codebases where model logic, tools, UI, storage and business logic become tightly connected.

DeepSeek Harness takes another approach.

Its architecture attempts to keep these capabilities separate:

Agent → Capability → Service → Provider

That makes it possible to replace or extend specific parts of the system without necessarily modifying the complete agent.

The repository documentation explicitly describes extension plugins as depending on Service Definitions rather than concrete providers, reinforcing this separation.

Who Can Use DeepSeek Harness?

The project can be useful for:

AI agent developers
AI coding-tool developers
Full-stack developers
Python developers
TypeScript developers
Researchers experimenting with agent architectures
Developers building multi-agent systems
Developers working with MCP
Developers building custom AI runtimes

For students learning AI engineering, it can also serve as a practical example of how a large agent system can be broken into modular services.

What Can Developers Learn From It?

DeepSeek Harness is useful to study if you're interested in agent infrastructure rather than only prompting.

Important concepts visible in the project include:

Agent loops
Plugin architecture
Service-oriented design
LLM provider abstraction
Tool registries
Session event logs
Skills
Subagents
MCP integration
JSON-RPC
Persistent workspaces
Python SDKs
Web interfaces

These concepts are increasingly relevant when building production-oriented AI applications.

Project Status

DeepSeek Harness is currently a developer preview.

The official repository states that development is moving quickly and that compatibility-breaking changes should be expected. The project also directs users to review its safety notice before running it.

So developers exploring the repository should treat its APIs and architecture as actively evolving rather than assuming long-term API stability.

License

DeepSeek Harness is released under the MIT License. Third-party dependencies and their respective licenses are documented separately in the repository.