Most developers have seen this bug before. You start filling out a form. Something causes the UI to re-render, and suddenly the text you were typing disappears.
Historically, this was an occasional annoyance. But with agent-generated interfaces, this failure mode happens constantly. AI systems regenerate entire UIs mid-session. Fields move, nodes get renamed, layouts restructure, and containers disappear.
I call this "The Ephemerality Gap", the mismatch between ephemeral, regenerating interfaces and durable user intent. Traditional UI frameworks assume the structure of the interface is mostly stable. When the structure mutates, the mapping between UI nodes and user state breaks.
React actually solved a very similar problem for the DOM. React’s Fiber engine answers the question: "Is this component the same as before?" by matching identity (type + key) to preserve component state across DOM mutations.
Continuum applies this exact same conceptual pattern, but to user data instead of DOM nodes. Where React protects component state across DOM changes, Continuum protects user state across UI schema changes.
It is a pure, stateless reconciliation engine designed to sit between view generation and rendering:
AI / Server
-->
ViewDefinition (UI Structure)
->
Continuum Runtime (State Continuity Layer)
- deterministic reconciliation - state migration
- detached state retention
- proposal / conflict handling
-->
Framework Renderer
-->
DataSnapshot (Durable User State)
The core runtime explicitly separates UI structure from user state. When the interface evolves, a deterministic reconcile() bridge maps existing user data onto the new view.
A few core capabilities:
Semantic Reconciliation: If the AI changes node IDs or wraps them in a new Grid, Continuum reconciles via stable semantic keys so state survives massive layout overhauls.
Detached State Retention: If an agent temporarily removes a field, Continuum doesn't throw the data away. It caches it as a "Detached Value" and automatically restores it if the field returns in a future turn.
Deterministic Migrations: The system is entirely deterministic. If an agent upgrades a simple text field to a complex collection, the runtime automatically migrates the data payload seamlessly across view transitions without requiring manual intervention.
The core SDK is 100% pure TypeScript with zero I/O side-effects, making it entirely framework-agnostic. I built a headless React SDK and an open-source starter kit to get a working environment running in minutes, and an Angular SDK is up next on the roadmap.
Curious how others are handling this state continuity problem. Does your team end up reinventing a custom reconciliation layer when building agent-driven UIs?
brytoncooper•2h ago
Most developers have seen this bug before. You start filling out a form. Something causes the UI to re-render, and suddenly the text you were typing disappears.
Historically, this was an occasional annoyance. But with agent-generated interfaces, this failure mode happens constantly. AI systems regenerate entire UIs mid-session. Fields move, nodes get renamed, layouts restructure, and containers disappear.
I call this "The Ephemerality Gap", the mismatch between ephemeral, regenerating interfaces and durable user intent. Traditional UI frameworks assume the structure of the interface is mostly stable. When the structure mutates, the mapping between UI nodes and user state breaks.
React actually solved a very similar problem for the DOM. React’s Fiber engine answers the question: "Is this component the same as before?" by matching identity (type + key) to preserve component state across DOM mutations.
Continuum applies this exact same conceptual pattern, but to user data instead of DOM nodes. Where React protects component state across DOM changes, Continuum protects user state across UI schema changes.
It is a pure, stateless reconciliation engine designed to sit between view generation and rendering:
AI / Server --> ViewDefinition (UI Structure) -> Continuum Runtime (State Continuity Layer) - deterministic reconciliation - state migration - detached state retention - proposal / conflict handling --> Framework Renderer --> DataSnapshot (Durable User State)
The core runtime explicitly separates UI structure from user state. When the interface evolves, a deterministic reconcile() bridge maps existing user data onto the new view.
A few core capabilities:
Semantic Reconciliation: If the AI changes node IDs or wraps them in a new Grid, Continuum reconciles via stable semantic keys so state survives massive layout overhauls.
Detached State Retention: If an agent temporarily removes a field, Continuum doesn't throw the data away. It caches it as a "Detached Value" and automatically restores it if the field returns in a future turn.
Deterministic Migrations: The system is entirely deterministic. If an agent upgrades a simple text field to a complex collection, the runtime automatically migrates the data payload seamlessly across view transitions without requiring manual intervention.
The core SDK is 100% pure TypeScript with zero I/O side-effects, making it entirely framework-agnostic. I built a headless React SDK and an open-source starter kit to get a working environment running in minutes, and an Angular SDK is up next on the roadmap.
Repo: https://github.com/brytoncooper/continuum-dev
Curious how others are handling this state continuity problem. Does your team end up reinventing a custom reconciliation layer when building agent-driven UIs?