DeepSeek Harness implements RSI (Recursive Self-Improvement) for agents. The paper provides the missing infrastructure layer that makes continuous, safe self-modification practical rather than theoretical. Core problem it solves for RSI: Most RSI discussions focus on an agent improving its model weights, code, or algorithms. Real agents, however, also need to continuously rewrite their own harness — the runtime system that supplies tools, memory, sandboxes, orchestration loops, skills, sessions, and interfaces. Without proper guarantees, a self-modification can: Leave irreversible side effects Break dependency chains Destroy the recovery mechanism itself Force a full process restart (interrupting continuous evolution) This is the classic “agent kills itself while trying to improve itself” failure mode. The proposed solution: Spatiotemporal Composability The paper formalizes two orthogonal properties required for safe RSI: Temporal composability (time dimension): Every side effect a component produces must carry an explicit inverse. When the agent unloads or replaces a component, the runtime can automatically and completely undo all its effects (state changes, resource registrations, listeners, etc.). Bad self-improvements become reversible. Spatial composability (space dimension): Components declare their dependencies. When a provider appears, disappears, or is replaced, the system reactively recomputes only the affected parts of the dependency graph. The agent does not need manual boot-order management or global restarts. These are unified into a single context programming paradigm and given a formal calculus whose metatheory proves that the properties lift from individual components to an entire interleaved system. Key theoretical result relevant to RSI Under reasonable conditions (independence + acyclic dependencies), the system has confluence: after any sequence of dynamic loads, unloads, and replacements, the final stable state is equivalent to the state that would result from assembling the final configuration from scratch. Intermediate evolutionary steps leave no permanent traces. This is crucial for open-ended self-improvement — the agent can explore many self-modifications without accumulating irreversible technical debt. Practical implication Implemented in the Cordis meta-framework (used by DeepSeek Harness), this turns the entire agent stack into hot-swappable plugins. An RSI-capable agent can therefore: Generate, deploy, and replace its own tools, memory systems, orchestrators, etc., while remaining online Isolate failures locally Roll back failed improvements cleanly Keep evolving indefinitely without process restarts In short: the paper shifts the RSI bottleneck from “can the model write better code?” to “can the agent safely rewrite the substrate it is running on?” It supplies the formal and engineering foundation for the latter. github.com/cordiverse/paper