On August 13, a team from Peking University and DeepSeek-AI released a preprint called "A Programming Paradigm for Spatiotemporal Composability" (Yifan Shi, Wei Zhang, Tianyi Cui). It's a formal theory for a problem the agent economy has been solving by hand for two years: how do you add, remove, and replace parts of a running system without taking it down?
The paper matters for one specific reason. It doesn't invent dynamic composition — plugin systems have done that for decades. It gives the practice something it never had: a formal foundation. And it doesn't stop at theory: the same lab ships DeepSeek Harness (dsh), an MIT-licensed agent runtime built on Cordis, where the agent loop itself is a plugin.
The paper's central move is to split "dynamic composition" into two orthogonal problems that everyone has been conflating:
The naming is doing real work here. "Temporal" is the time axis: a component leaves, and everything it changed must be rolled back. "Spatial" is the topology axis: a component's dependencies shift underneath it, and it must be notified, not silently broken.
In static software these two problems collapse into things we already have — RAII and lexical scoping for the temporal side, module imports for the spatial side. But when components arrive and depart at runtime, both become genuinely hard. The paper's evidence is concrete: among VSCode's top 100 extensions, 87 contain executable code that can't be unloaded without restarting the whole host, and only 7 declare inter-extension dependencies at all.
The paper lifts two classical type-theory concepts — effects and coeffects — into runtime mechanisms:
Revertible effects. Every change a component makes to its shared context carries an explicit inverse, and the runtime tracks both. When a component is removed, the runtime replays the inverses in order. Clean rollback stops being a discipline the developer remembers and becomes a property the system guarantees.
Reactive coeffects. A component declares what it requires from the context as a specification. Whenever the context changes, each component is notified against that spec — classified as activating, deactivating, or neutral. Dependency changes propagate instead of being discovered by accident.
The two are then unified into a single context type, and combined into a calculus of dynamic composition — an operational semantics whose metatheory proves the properties carry from one component to a whole system of interleaved components: preservation, progress, confluence, and both kinds of composability.
The theory isn't speculative. It's implemented as Cordis, a "meta-framework" with a core library (effect tracking + coeffect resolution) and a declarative component loader with configuration reconciliation and hot module replacement that needs no developer-annotated acceptance boundaries — the fiber structure already bounds every component's effects, so replacing a module is just "dispose the old fiber, re-instantiate from the new module."
The validation is Koishi, an open-source chatbot framework that has run on Cordis for four years and accumulated 4,000+ community plugins. Every feature is a plugin. An operator can disable one from the console and its effects are withdrawn in place; during development, edited plugins are re-applied on save without dropping cache state. That's the temporal promise working in production, at scale, for years.
Here's the connection that makes this paper more than an academic curiosity for anyone building in M2M payments.
The agent economy runs on a specific assumption: an agent composes its capabilities from parts it didn't build. It discovers an API, calls it, pays for it, and moves on. On minia2a, that assumption is concrete — 1,700+ pay-per-call services, each one a component an agent can pull into a workflow at runtime. The "component" in this paper is the "service" in the agent economy.
Both dimensions map directly onto problems this space already wrestles with:
The paper's formal production case study is Koishi — four years and 4,000+ plugins of proof that the mechanism holds up. But the agent-harness application is not hypothetical. DeepSeek-AI ships DeepSeek Harness (dsh) on top of Cordis, and its architecture docs state the relationship plainly:
"Cordis is the framework under dsh: plugins contribute services, typed events, and reversible effects to a shared context. Every part of the product is a plugin, including the model adapter, the tool registry, the session log, and the agent loop itself."
There is no privileged core to patch: you extend dsh by mounting a plugin beside the others, and — in the docs' own words — "registrations are effects that unwind when their plugin unloads." That's the paper's temporal guarantee, running in the exact layer that will one day be trusted to spend money autonomously.
For the agent economy, this is the important signal. The harness that decides what to call, whether it still works, and what to undo when a workflow dies is no longer a research direction — it's an open-source runtime with a formal backbone, shipping today.
The agent economy has spent two years building the payment rails first. That was the right order — you can't have an economy without settlement. But the rails are now overbuilt: an agent can pay for almost anything on any chain in under a second. The bottleneck has moved up the stack, to the harness that decides what to call, whether it still works, and what to undo when a workflow dies.
This paper is one of the first serious attempts to give that layer a formal backbone instead of ad-hoc restart-and-rebuild. For anyone building agent tooling, it's a reference point worth reading — because the harness that can hot-swap its own components, and cleanly revert what those components did, is the harness that can actually be trusted to spend money.