Runtime-Independent Persistent Agents: Preserving Identity, Memory, and Code Across Models, Harnesses, and Servers
Zhenyu Zhao and Roy Zhao argue that describing an agent by its current model and harness underspecifies a long-lived agent, and give a runtime-independent architecture that separates a continuity-bearing substrate from a replaceable deployment binding.
Ask this paper
The formalism. A persistent substrate carries architectural identity, private durable memory, and a versioned software body. A deployment binding supplies reasoner, harness, and host plus interaction surfaces. A deployed execution composes the two.
Migration, not creation. Changing either replaceable layer counts as migration rather than instantiating a new agent, provided an authorized protocol preserves attributable lineage and transfers continuation authority inside a governed boundary.
Six invariants and a protocol. The quiesce, checkpoint, validate, bind, rehydrate, resume sequence is the operational core, and Enoch realizes it as a reusable body plus private installed identity, memory, workflow state, and continuation authority.
Evidence is mechanical, and labeled as such. A clean-room run of the frozen public commit passes 833 core tests plus 92 provider and library tests, with deployments exercising reasoner-version, interaction-surface, and host-machine substitutions. The authors are explicit that this supports substitutability and authorized continuity, not behavioral invariance.
The open question they name. Whether an authorized continuation still recalls, composes, and enacts its identity is the downstream measurement problem, and it is not answered here.
Abstract
Agent systems are commonly described by the model and harness that currently produce their behavior. That boundary is useful for one execution but underspecifies a long-lived agent that may change models, orchestration harnesses, interaction sessions, and host servers while retaining one identity, memory, and executable code lineage. We present a runtime-independent architecture for persistent agents. A continuity-bearing substrate $P_t=(I_t,M_t,B_t)$ contains an architectural identity representation, private durable memory, and a versioned software body. A replaceable deployment binding comprises an execution substrate $E_t=(R_t,H_t,D_t)$, which supplies a reasoner, harness, and host, and a set of interaction surfaces $S_t$, such as chat, API, or user interface bindings. A deployed execution is $A_t=P_t\triangleright(E_t,S_t)$; changing either replaceable layer is migration, not agent creation, when an authorized protocol preserves attributable lineage and transfers continuation authority within a governed deployment boundary. We define six continuity invariants and a quiesce--checkpoint--validate--bind--rehydrate--resume protocol. Enoch realizes the design as a reusable body plus private installed identity, memory, workflow state, and continuation authority, with infrastructure dependencies behind versioned provider contracts. A clean-room run of the frozen public commit passes 833 core tests and 92 provider and library tests executed separately from the core suite; deployments have exercised reasoner-version, interaction-surface, and host-machine substitutions while retaining continuity-bearing state. This evidence supports mechanical substitutability and authorized system continuity, not behavioral invariance or exhaustive pairwise evaluation. The downstream measurement question is whether an authorized continuation still recalls, composes, and enacts its identity.