Why DeepSeek Harness Lets AI Agents Rewrite Themselves—and What They Fear Most

DeepSeek Harness is an open‑source agent framework from DeepSeek‑AI that tackles the core challenge of “dynamic composition”: allowing an AI agent to continuously generate, replace, and unload its own tools and modules without stopping service.

1. Splitting the problem into two orthogonal dimensions

Time dimension : when a module is removed, all its side‑effects—event registrations, memory allocations, file handles, network connections—must be completely reclaimed. Failure to do so leads to leaks, ghost listeners, or worse, a previous version of the agent silently running in the background.

Space dimension : modules declare the dependencies they need (e.g., module A needs a database from B, module C needs an interface from A). At runtime, dependencies can appear or disappear, and naïve static import mechanisms break down.

In a static world, RAII and lexical scopes solve the time problem, while import statements solve the space problem. At runtime, where components can be loaded, unloaded, or swapped at any moment, those solutions no longer apply.

2. Core idea: revertible effects + reactive coeffects

The paper introduces two classic language‑theory concepts:

Effect : what a computation does to the external world.

Coeffect : what a computation requires from the external world.

Instead of performing static analysis on these concepts, the paper proposes handling them at runtime.

Revertible effects (the “self‑undo” side of Effect) attach an inverse operation to every side‑effect. When a module is unloaded, the framework walks the recorded undo keys in LIFO order, restoring the environment.

this.ctx.effect(function* (this: SessionStore) {
    yield this.enter(session)   // yield produces the undo key
    this.announce(session)
}, 'sessions.create()')

In the example above, yield returns a key that removes the session. The comment in the source explains that if an exception occurs after announce, the generator automatically rolls back the already‑yielded undo key, preventing leaks.

Reactive coeffects let a module declare the services it needs. The framework maintains a table of currently available services; when a declaration becomes satisfied, the module is activated, otherwise it stays inactive.

export class SessionStore extends Service {
    constructor(ctx: Context) {
        super(ctx, 'sessions')          // provides "sessions"
        ctx.inject(['typert'], (ctx) => { // requires "typert"
            /* ... */
        })
    }
}

Here super(ctx, 'sessions') declares what the module provides, while ctx.inject(['typert'], ...) declares what it needs. The module runs only after its dependencies are ready, forming a complete component interface.

3. Theorem: dynamic history leaves no trace

Regardless of how many loads, unloads, replacements, or rollbacks occur at runtime, the final system state is identical to the state obtained by a single static assembly of the final configuration.

In plain terms, all the runtime tinkering disappears; the system converges to a clean state as if it had been assembled once from scratch. This guarantees that an agent can experiment freely: if a change fails, it can be rolled back without leaving any residual state.

4. How Harness puts the theory into practice

Rather than treating the Cordis framework as an external dependency, Harness vendors (embeds) the entire Cordis codebase, making it auditable, patchable, and version‑pinned.

“harness fully owns its framework layer (auditable, patchable, pinned).”

The vendored code adds a guard mechanism that enforces the crucial rule: a module must wait for all modules that depend on it to exit before it can withdraw its own dependencies. The paper proves this guard never deadlocks and always terminates.

5. Concrete evidence: 18 patches to Cordis

The repository’s vendor/README.md lists 18 local modifications to upstream Cordis, directly demonstrating where the paper’s theorems would break in a real system and how the authors patched them. Three notable patches are:

Fix re‑entrant unload : during unload, a second unload could be triggered, causing resource leaks; the patch hard‑wires a guard.

Transactional configuration rollback : when swapping a plugin, the new plugin is loaded first; if the lifecycle fails, the system rolls back to the old plugin, matching the paper’s “hot‑module replacement rollback”.

Resolve concurrent deadlock : simultaneous configuration changes could interleave creation and rollback, deadlocking the fiber; a serialization queue was added.

These patches show the engineering effort required to satisfy the theoretical guarantees in production.

6. The broader ambition

The paper’s final outlook envisions “self‑evolving agent systems”. The combination of revertible effects (a safety net in the time dimension) and reactive coeffects (automatic coordination in the space dimension) provides exactly the two missing pieces for software that can safely modify itself. DeepSeek Harness is the first production‑grade realization of this theory, with 73 Service classes spread across packages and even the agent loop itself being a replaceable plugin.

One‑sentence summary : The lack of a mathematical foundation for dynamic composition caused agents to require restarts for code changes; the paper supplies that foundation—each side‑effect carries an undo key and each dependency is automatically coordinated—proving that, no matter how much the system is tinkered with, it always settles into a clean state equivalent to a static assembly, and DeepSeek Harness is the first production system that embodies this insight.