DeepSeek has spent months hinting that its desktop app — the “black whale” Harness — is a staging ground for something much bigger. An 80-page paper with Peking University, published this week, reveals the engineering backbone of that ambition: a programming paradigm for “spatiotemporal composability” that makes agent runtimes genuinely self-modifiable. The core artifact is Cordis, a meta-framework for reversible plugin systems that the Harness team has been hardening for four years. This is the closest look yet at how DeepSeek intends to let AI agents modify their own software — live, without breaking the machine.
Why self-evolving agents need a new kind of runtime
Almost every plugin architecture in the software world has the same dirty secret: once a plugin is loaded, it cannot be cleanly removed. The paper cites VSCode as the canonical case — as of June 9, 2026, 87 of the top 100 extensions in the Marketplace contain executable code that cannot be unloaded individually at runtime. Disable or delete one, and you must restart the entire extension host, taking every other loaded extension down with it.
In a normal editor that is an annoyance. In an agent runtime it is existential. A modern agent host is packed with tool sets, execution environments, permission controls, sandboxes, session state and memory systems. Restarting the process throws away accumulated context and caches — and an agent’s context is its working memory.
Now add the self-evolution ambition: future agents will generate their own tools, load them into the runtime, test them, and replace them when they fail. If every one-line code change demands a full process restart, the agent loses everything it knew each time it improves itself. The paper calls this time composability — the ability to change a component without paying the cost of restarting the world around it.
The second half of the problem is space composability. When modules maintain their own dependencies by patching each other ad hoc, circular dependencies sneak in and detonate on reload. A runtime that wants to survive self-modification needs dependency topology that is derived, not hand-maintained.
The fix: reversible effects and reactive coeffects
The mathematical roots come from type theory: effects describe what a program does to the world, and coeffects describe what the world constrains the program with. They are dual concepts — effects enrich types, coeffects enrich context. But classic effect systems are static type tools, and a self-evolving runtime loads frameworks dynamically. So the DeepSeek team adapted both concepts for agent runtimes:
Revertible effects attack the time dimension. Every mutation of context must register an explicit inverse function. When a plugin loads, its inverse functions stack into an undo chain; when it unloads, the chain is walked backward and system state returns exactly to its pre-load position. Think of a stack of plates — the last one placed is the first one removed. Time order can no longer corrupt state.
Reactive coeffects handle the space dimension. Components declare which dependencies they need, and the framework keeps them INACTIVE until every dependency resolves. Providers appear → dependents auto-activate. Providers leave → dependents pause first, retract their effects, and only then does the provider finish unloading. The orchestration is inferred from declarations, never hand-written.
Together they deliver the paper’s title: components that load and unload dynamically, with precise state recovery and automatically maintained dependency topology.
Proof, not vaporware: four years and 4,000 plugins on Koishi
The paradigm is not new lab work — it has been running in production for years. Cordis (Latin for “heart”) is the foundation of Koishi, a chat-bot framework created by Yifan Shi, the paper’s first author, who is jointly at Peking University and DeepSeek. Over four years Koishi has accumulated more than 4,000 community plugins covering IM adapters, database drivers, admin consoles and user features.
The paper documents the mechanics in practice: an admin disables a plugin from the console and its effects are retracted in place while every other plugin keeps running; a developer edits and saves a plugin and it hot-reloads without touching caches or connections; switching a storage backend reactivates only the plugins whose dependencies actually changed — plugins from different authors, coordinated by nothing but the reactive coeffect rules.
The team is honest about limits: single ecosystem (Koishi), single language (TypeScript), and no controlled comparison against alternative architectures. But this is a working existence proof — and DeepSeek Harness is Cordis 2.0 at product scale.
What this means for the agent economy
The agent war is quietly moving from model quality to runtime infrastructure. Whoever lets agents modify themselves safely wins the long game — the same battlefield where Cloudflare is building persistent runtimes for agents. DeepSeek just published the missing piece: a mathematically grounded way to make that self-modification safe.
Three consequences follow. First, self-evolving agents — write a tool, load it, test it, replace it — stop being science fiction and become a systems-engineering roadmap with published theory. Second, plugin ecosystems become safe to mutate at runtime: memory, tools and skills become hot-swappable, and the “plug and pray” era of restart-on-every-change ends. Third, reversibility becomes a general design principle: any system that allows software to modify itself must ship undo semantics first. That pattern will spread far beyond DeepSeek, into every long-running agent host, including locally deployed agent setups.
DeepSeek’s strategic play is a flywheel: an open paradigm, a viral plugin culture around Harness, and now the underlying theory to anchor it. That combination is hard to copy quickly.
What to do with this now
Developers: read the paper (github.com/cordiverse/paper) and the Koishi source. The reversible-effects pattern is directly reusable in your own agent tooling — you do not need to wait for DeepSeek to ship it.
Builders of agent runtimes: add undo-chain state management before you add self-modification features. Reversibility is the missing primitive, and retrofitting it later is painful.
Teams evaluating agent platforms: ask whether the runtime can swap tools and skills live without restarts. That capability just became a benchmark, not a nice-to-have.
Watchers: track the DeepSeek Harness roadmap and the Koishi/Cordis repositories. The self-evolving agent stack is arriving faster than the mainstream expects.