Cordis: Spatiotemporal Composability
Modern software — from plugin systems to self-evolving agent harnesses — increasingly requires dynamic composition, yet its formal foundations remain underdeveloped. The paper A Programming Paradigm for Spatiotemporal Composability provides the theory, implemented by the Cordis meta-framework. DeepSeek Harness is built on top of Cordis.
Why Dynamic Composition
Plugin systems need to mount cleanly and unmount cleanly; self-evolving agent harnesses need to load, swap, and recompose capabilities at runtime. Components must be safely composable and revertible in both time and space — exactly what the paper formalizes.
Two Orthogonal Dimensions
Temporal Composability
The ability to completely revert a component's side effects upon removal. Plug-and-play is only the beginning — clean unplug is the hard part.
Spatial Composability
The ability to declare and reactively manage inter-component dependencies. Collaboration between components should never rely on fragile manual wiring.
From Effects & Coeffects to Runtime Mechanisms
The paper lifts classical effect and coeffect concepts to runtime mechanisms, addressing both the temporal and spatial dimensions.
Revertible Effects
Every context transformation carries an inverse that the runtime tracks. Removing a component replays the record backwards, fully reverting its side effects.
Reactive Coeffects
Each change of the context notifies a component against its coeffect specification. Dependencies become declarative and reactive.
A Unified Context Type
The effect context and the coeffect context are unified into a single context type — and that unification constitutes a programming paradigm.
Components & a Calculus of Dynamic Composition
These mechanisms combine into the notion of a component, with a calculus of dynamic composition whose metatheory carries spatiotemporal composability from a single component to a whole system of interleaved components.
The Cordis Meta-Framework
The theory is implemented in Cordis: a meta-framework of spatiotemporal composability that powers the DeepSeek Harness kernel.
Core Library
Effect tracking and coeffect resolution — reversible execution and reactive dependency management.
Declarative Component Loader
Configuration reconciliation and hot module replacement — components load declaratively from configuration.
Plugin Lifecycle Management
The Cordis kernel manages plugin mounting, unmounting, and dependencies. Agent capabilities live in the plugins — never in the kernel.
Context Transformations and Their Inverses
In Cordis, every context transformation is tracked by the runtime, carrying its inverse:
// Conceptual sketch: a revertible context transformation
ctx.apply({
forward: () => mountPlugin(plugin), // transformation: mount the plugin
inverse: () => unmountPlugin(plugin), // inverse: unmount and revert side effects
});
// Removing a component replays the record backwards
ctx.revert(plugin); // side effects fully reverted, dependents notifiedRead the Paper
A Programming Paradigm for Spatiotemporal Composability is a preprint (draft of August 13, 2026) by Shigma, under active revision. Cite the latest version and check back before relying on specific results.
A Programming Paradigm for Spatiotemporal Composability
cordiverse/paper · github.com/cordiverse/paper · github.com/cordiverse/cordis
Learn More
FAQ
What is the relationship between Cordis and DeepSeek Harness?
Cordis is a meta-framework of spatiotemporal composability providing plugin mounting, unmounting, dependency management, and effect tracking. DeepSeek Harness is built on Cordis, implementing models, tools, skills, sandboxes, and every other agent capability as plugins.
What is spatiotemporal composability?
A concept from the paper: the temporal dimension means a component's side effects can be completely reverted upon removal; the spatial dimension means inter-component dependencies can be declared and reactively managed. The two dimensions are orthogonal and together formalize dynamic composition.
What are revertible effects and reactive coeffects?
Revertible effects: every context transformation carries an inverse tracked by the runtime. Reactive coeffects: context changes notify components against their declared coeffect specifications. Unified as a single context type, they constitute a new programming paradigm.
Why does hot module replacement matter for plugin development?
Together with configuration reconciliation, you can swap and recompose plugins without restarting the server — experimenting with new agent capability combinations live. This underpins Creator mode's in-memory plugin experiments.