State of the Art, Not State of Everything: Why Better AI Remembers Less

TL;DR for operators

Production AI does not become reliable by remembering everything. It becomes reliable by preserving the information that defines the current state, explicitly representing what is allowed to change, and discarding history that would contaminate the next decision.

Two papers arrive at this conclusion from remarkably different directions. One generates future amyloid-PET scans by anchoring the generative process to a patient’s baseline scan. The other builds persistent enterprise agents by retaining specifications, schemas, tools, and output contracts while deleting prior reasoning traces.

The operating principle is the same:

—not:

For businesses, the implication is practical. Stop treating a larger context window as a memory strategy. Define a state contract: what must persist, what may change, what must expire, and how the transition will be tested.

The Context Window Is Not a Memory Strategy

AI systems are increasingly expected to operate across time.

A medical model must estimate what has changed since a patient’s previous scan. A reporting agent must update a dashboard without forgetting its formatting rules. A service assistant must remember the approved customer context without resurrecting an obsolete exception. A coding agent must continue a project without becoming emotionally attached to Tuesday’s failed shell command.

These systems face a problem that is often described too loosely as “memory.”

That label encourages an unfortunate architectural reflex: retain more tokens, retrieve more documents, preserve more transcripts, and hope the model sorts out relevance during inference. The approach is intuitively appealing. It is also rather like improving an employee’s judgment by forwarding every email the company has ever sent.

The more precise problem is continuity. A system must produce a new state that remains consistent with what should endure while changing in response to what has genuinely changed.

That requires discrimination, not accumulation.

A longitudinal brain-imaging framework called $\Delta$-Diffusion and an enterprise-agent architecture called Shared Selective Persistent Memory appear, at first, to have little in common. One models amyloid progression in PET volumes. The other manages dashboards, reports, data connectors, and generated code. Yet both papers expose the same design principle: a temporal AI system needs a carefully engineered representation of state, not an indiscriminate archive of history.¹²

One paper preserves a rich baseline. The other aggressively forgets prior execution. They are not contradicting each other. They are preserving different forms of the same thing: the minimum information required to constrain the next valid transition.

The Shared Failure: Drift on One Side, Copying on the Other

Systems that operate across time tend to fail in two opposite ways.

The first is drift. The output changes, but no longer belongs to the same underlying entity, process, patient, customer, or workflow. In medical imaging, anatomical identity may shift. In enterprise work, formatting constraints, data semantics, or approved operating assumptions disappear between sessions.

The second is stasis disguised as consistency. The system preserves the past so faithfully that it fails to represent meaningful change. A longitudinal image generator may reproduce the baseline scan. An enterprise agent may repeat a previous solution path even though the data, request, or operating environment has changed.

These failures can be expressed as a simple tension:

Failure	What the system preserves	What the system loses
Drift	Capacity to generate something new	Identity and continuity
Copying	Surface similarity to the past	Legitimate temporal change
History anchoring	Previous reasoning and execution patterns	Responsiveness to the current task
Stateless restart	Nothing	Reusable constraints and accumulated configuration

The desired behavior sits between these extremes. The system must preserve identity without freezing it.

That is the shared insight connecting the papers.

Continuity Is a State-Selection Problem

A useful abstraction is to separate three categories of information:

• $A_t$: the durable anchor at time $t$;
• $C_{t \rightarrow t+1}$: the variables that legitimately govern change;
• $H_t$: incidental historical traces produced while reaching the current state.

A well-designed temporal system should approximate:

The crucial architectural decision is whether anything from $H_t$ belongs in that conditional distribution.

Sometimes it does. A verified artifact, accepted user preference, approved configuration, or clinically observed baseline may be essential.

Often it does not. Temporary files, retries, abandoned drafts, tool logs, outdated workarounds, and unapproved changes usually describe how the system once arrived somewhere—not what the next state is required to be.

This distinction is easy to state and surprisingly rare in deployed systems. Many products still confuse provenance with context, context with memory, and memory with keeping the transcript indefinitely. Three different concepts are thus bundled into one expensive prompt.

The two papers separate them more carefully.

Anchor the Transition, Not Just the Prompt

$\Delta$-Diffusion addresses a difficult longitudinal imaging task: synthesizing a follow-up amyloid-PET scan from a subject’s baseline PET, structural MRI, and the elapsed interval between scans.¹

The problem is not ordinary image generation. The future scan must remain anatomically consistent with the same individual while reflecting subtle changes in amyloid deposition. A generic noise-to-image model can produce plausible PET images, but plausibility is not enough. The model must preserve subject identity and model progression simultaneously.

The authors therefore reformulate synthesis as a conditional diffusion bridge.

Instead of beginning with unstructured Gaussian noise and treating the baseline scan as another optional condition, the bridge is mathematically anchored to the observed baseline PET. Inference begins from that subject-specific state and solves the reverse bridge dynamics toward a possible follow-up state.

This changes what the model is being asked to learn. It is no longer merely generating an image that resembles the target distribution. It is learning a transition from one subject-specific observation to another.

Three additional design choices specify what legitimate change should look like.

First, the model receives the actual follow-up interval in days. This matters because a scan after three years should not be treated like a scan after six months. Temporal distance is injected into the Diffusion Transformer through adaptive modulation.

Second, structural T1-weighted MRI provides an anatomical prior. The baseline PET anchors functional identity, while MRI supplies structural context that should remain coherent through the transition.

Third, the perturbation process reflects PET acquisition physics. PET measurements originate from photon counts and exhibit signal-dependent Poisson noise. The authors therefore introduce Poisson perturbation in the projection domain rather than relying solely on the Gaussian corruption commonly used in diffusion models.

The architecture is not simply “more conditioned.” Each condition has a distinct job:

Component	State function
Baseline PET	Anchors subject-specific functional state
Structural MRI	Constrains anatomical continuity
Follow-up interval	Calibrates the scale of permissible change
Poisson perturbation	Aligns intermediate corruption with PET physics
VOI-balanced objective	Prioritizes clinically significant cortical regions

The volume-of-interest objective is particularly important. Amyloid accumulation is sparse and regionally meaningful. An ordinary whole-image loss can be dominated by large background or low-change regions, rewarding broad similarity while overlooking the areas that matter clinically. The paper therefore balances performance within cortical volumes of interest against global structural fidelity.

Across OASIS-3 and ADNI, covering 542 subjects, the authors report the highest whole-image and region-level PSNR and SSIM among the evaluated methods. On OASIS-3, the reported whole-image PSNR reaches 28.6489, compared with 25.1127 for the strongest listed comparator. On ADNI, the gain is narrower but remains positive: 25.1723 against 24.5516.

The ablation results are more informative than the leaderboard. Removing the combined Poisson perturbation, MRI guidance, temporal guidance, and VOI-balanced loss produces the largest deterioration. Reduced variants retain reasonable structural similarity, but the full configuration performs best on the clinically targeted regional metric.

In other words, the model improves not because it is given the baseline and told to “keep things consistent.” It improves because the architecture defines what consistency means and separately encodes what is allowed to change.

That is a much stronger state model than dropping the previous scan somewhere into a context window and hoping attention behaves responsibly.

Keep the Contract, Delete the Transcript

Shared Selective Persistent Memory confronts the same state-selection problem in agentic enterprise systems.²

Here the discontinuity occurs between sessions rather than clinical visits. An agent may generate a dashboard today, refine it next week, and adapt it for another team next month. Without persistent context, users must repeatedly specify data meanings, formatting rules, tool configurations, and runtime constraints.

The obvious remedy is to preserve the entire conversation.

The paper tests that remedy and finds it worse than starting with no memory.

Its alternative is to retain four structured memory categories:

1. Task specifications: domain rules, generation preferences, formatting requirements, and quality constraints.
2. Data schemas: column names, types, distributions, categorical values, row counts, relationships, and representative samples.
3. Tool configurations: available connectors, parameter schemas, authentication requirements, and invocation patterns.
4. Output constraints: contracts governing how generated artifacts interact with their runtime environment.

This is declarative state. It describes what the system is supposed to build, what data structure it can expect, which capabilities are available, and which constraints must hold.

The architecture explicitly discards:

• reasoning traces;
• temporary files;
• tool invocation logs;
• failed recovery paths;
• unapproved changes;
• raw data once a compact schema profile has been produced.

The distinction is not between memory and forgetting. It is between state memory and execution residue.

At the start of each session, the application composes the persistent specification, schema, tool, and output components into a new prompt. The model does not receive the previous conversation. It receives a curated representation of the workspace’s current contract.

That contract also enables the paper’s “zero-token refresh” mechanism. Generated programs must consume data from a runtime injection point rather than embedding source values. When new data arrive, the system checks whether the expected columns remain available. If the schema is compatible, the existing artifact renders against the new data without another LLM call.

This is an architectural improvement, not a sudden awakening of model intelligence. The paper is admirably clear about the difference.

In the authors’ 24-task enterprise evaluation, selective memory achieved 96% completion, compared with 79% for no memory and 71% for full-history persistence. It also required fewer user turns and less wall-clock time. Full history consumed substantially more input tokens yet completed fewer tasks, with failures attributed largely to stale trace anchoring.

The public-dataset replication is narrower but directionally consistent. For four datasets, the zero-token refresh condition succeeded in all 12 trials because the replacement data retained compatible schemas. The important boundary is contained inside that sentence: because the schemas were compatible. Zero-token regeneration is powerful when the program contract remains valid. It is not a magical exemption from schema drift.

The paper’s token results make the same architectural point. Statistical data summaries remained below roughly one thousand tokens while raw tabular injection scaled dramatically with dataset size. Truncated samples were cheaper but omitted rare categories and tail distributions, causing errors in several enterprise tasks.

So the winning strategy was not maximal data exposure. It was a compact representation selected for the downstream task.

Again, the model improves by seeing less—but seeing the right less.

One Principle, Two Very Different Implementations

The papers preserve different objects because their domains require different anchors.

Design question	Longitudinal PET synthesis	Enterprise agent memory
What must persist?	Subject-specific baseline PET and anatomy	Specifications, schemas, tools, output contracts, accepted artifacts
What may legitimately change?	Amyloid distribution over an elapsed clinical interval	Runtime data, user request, approved refinements, connected source
What should not dominate the next state?	Generic population appearance or trivial baseline replication	Old transcripts, tool traces, retries, temporary files
Primary drift risk	Anatomical or subject-identity drift	Loss of workspace rules and data semantics
Primary copying risk	Reproducing baseline intensities without progression	Repeating stale reasoning or hardcoded prior outputs
Transition mechanism	Conditional Poisson diffusion bridge	Application-layer memory composition and runtime data injection
Validity test	Image and region-level agreement with follow-up PET	Render correctness, data fidelity, constraint compliance, completeness

The superficial contrast is obvious. The medical model retains a dense, high-dimensional baseline image. The agent system discards most of its historical session.

The deeper logic is identical.

The PET baseline is not retained because “more history is better.” It is retained because it defines the identity of the subject whose future state is being modeled.

The agent transcript is not discarded because “memory is bad.” It is discarded because it does not reliably define the workspace’s valid future state.

State selection is domain-dependent. The governing criterion is not size, recency, or ease of storage. It is constraint relevance.

The Operator’s State Contract

The business interpretation begins here. Neither paper claims to provide a universal enterprise framework. Together, however, they suggest a useful design discipline for stateful AI applications: every recurring system should have an explicit state contract.

A state contract answers four questions.

1. What defines identity?

This is the durable anchor.

For a customer-service system, it may include the verified customer record, active product state, unresolved case status, and approved policy version.

For a reporting agent, it may include the metric definitions, data schema, visualization conventions, and published artifact.

For a maintenance model, it may include the machine configuration, latest verified sensor baseline, component history, and operating envelope.

The anchor should contain what the next output must remain consistent with—not everything that happened previously.

2. What variables permit change?

A temporal system needs an explicit change model.

In $\Delta$-Diffusion, the elapsed interval, anatomy, and stochastic bridge determine plausible progression. In an enterprise workspace, updated runtime data and the current user request determine what should change.

Business systems should be equally explicit. Legitimate transition variables might include:

• a newly approved transaction;
• a changed market price;
• a revised policy effective date;
• a new sensor observation;
• a user instruction with sufficient permission;
• an updated source whose schema remains compatible.

Without this layer, systems oscillate between arbitrary regeneration and cautious copying.

3. What history must be excluded?

Most organizations spend more time discussing what an AI system should remember than what it should forget.

That is backwards.

A production memory policy should explicitly identify non-state information:

• abandoned drafts;
• superseded policies;
• failed tool paths;
• temporary calculations;
• low-confidence model inferences;
• unapproved user suggestions;
• stale credentials;
• source data whose retention is unnecessary;
• intermediate reasoning that has not been validated as reusable knowledge.

Deletion is not merely a storage concern. It is an inference-quality control.

4. How will the transition be verified?

An output can look excellent while failing as a transition.

A dashboard may render correctly but use stale definitions. A customer response may be eloquent but refer to a closed case. A synthesized scan may resemble the patient while failing to represent progression. A regenerated report may preserve the template while silently hardcoding last week’s figures.

Evaluation therefore needs at least three dimensions:

Test	Question
Identity retention	Did the output preserve the entity, rules, and constraints that should remain stable?
Transition sensitivity	Did the output respond correctly to the variables that genuinely changed?
Historical resistance	Did irrelevant or stale history distort the new output?

Most current AI evaluations emphasize the first two unevenly and barely test the third.

That omission is becoming expensive.

Bigger Context Can Be a More Elaborate Failure

The agent-memory paper provides a useful warning for organizations equating context length with operational maturity.

A larger context window expands capacity. It does not determine relevance, resolve conflicts, establish authority, detect staleness, or distinguish approved state from discarded experimentation.

Those are application responsibilities.

The same is true of retrieval. A retrieval system can locate old documents, prior chats, and related artifacts. It does not automatically know whether an item is authoritative, current, compatible, or safe to inject into the present task.

The practical hierarchy is:

1. State model: What facts and constraints define the current valid state?
2. Authority model: Which source is allowed to update each component?
3. transition model: Which events or inputs permit change?
4. memory mechanism: How are relevant state components stored and retrieved?
5. model inference: How does the AI act under those constraints?

Many deployments begin at step five and then compensate by pouring additional material into the prompt. This produces impressive demos and unexpectedly archaeological production systems.

Versioning Is Part of Memory

The enterprise paper’s use of Git-backed artifacts and isolated drafts deserves more attention than it will probably receive.

Memory is often framed as a model feature. In practice, reliable persistence depends just as much on ordinary software controls:

• explicit saves;
• version histories;
• draft isolation;
• reversible changes;
• access roles;
• schema validation;
• separation of program logic from runtime data.

These mechanisms decide which changes become state.

An unapproved edit should not automatically enter persistent memory. A successful generated artifact should not be overwritten merely because a later experiment failed. A viewer’s local adaptation should not silently modify the shared source. A refreshed dataset should not trigger regeneration when the existing program remains valid.

None of this requires the model to become more intelligent. It requires the surrounding system to become less careless.

The imaging paper makes the equivalent move mathematically. The bridge architecture constrains where generation begins and what trajectory it may follow. The enterprise paper does it operationally through versioned artifacts and memory composition.

In both cases, continuity is enforced outside the model’s free-form generative impulse.

What the Papers Show—and What They Do Not

The papers provide credible evidence for their respective mechanisms, but neither justifies universal claims.

$\Delta$-Diffusion demonstrates improved synthesis metrics on two longitudinal amyloid-PET cohorts under a shared preprocessing and evaluation pipeline. The use of subject-level splits reduces leakage risk, and the ablation results support the combined value of baseline anchoring, temporal and anatomical conditioning, Poisson perturbation, and regional weighting.

It does not show that synthetic follow-up PET can replace acquired scans in clinical decision-making. PSNR and SSIM are useful reconstruction metrics, including when measured in clinically relevant regions, but they are not equivalent to prospective diagnostic validity, treatment impact, or calibrated patient-level uncertainty.

The enterprise-memory paper evaluates a deployed artifact-generation platform across real enterprise files, public datasets, and a 12-person user study. Its controlled comparison between no memory, full history, and selective memory directly supports the claim that curated persistence can outperform both forgetting and transcript retention.

Its scope is nevertheless concentrated around generated dashboards, reports, documents, and structured tabular data. The four-part memory decomposition is manually designed. Zero-token refresh assumes stable or additively compatible schemas. The study does not establish that reasoning traces are always harmful, nor that the same categories are sufficient for software engineering, scientific research, autonomous operations, or highly unstructured knowledge work.

Indeed, the authors themselves identify a future role for validated agent-level memory: reusable tool patterns, error-recovery heuristics, preference models, and cross-session plans. The unresolved problem is not whether procedural knowledge can be useful. It is how to retain it without preserving domain-specific accidents as universal wisdom.

That is the harder memory problem still waiting politely outside.

The Business Case for Remembering Less

The immediate business opportunity is not to purchase a more sentimental model. It is to reduce repeated work while increasing transition reliability.

Selective state architecture can improve four operational dimensions.

Cost: Compact schemas and reusable artifacts can reduce token consumption and unnecessary model calls.

Consistency: Persisted specifications and output contracts reduce repeated prompt engineering and format drift.

Adaptability: Separating stable logic from runtime data allows systems to refresh outputs without rebuilding them.

Governance: Versioning, approvals, access controls, and explicit forgetting make state changes inspectable and reversible.

These gains should be measured independently. A system may save tokens while becoming less accurate. It may preserve formatting while using stale logic. It may update instantly while failing to detect a broken schema. “Persistent memory enabled” is therefore not a useful KPI.

Better measures include:

• percentage of recurring tasks completed without re-specification;
• rate of correct adaptation after controlled input changes;
• number of stale-context failures;
• percentage of persistent fields with an owner and freshness rule;
• proportion of updates handled without model invocation;
• rollback frequency and recovery success;
• task performance under irrelevant-history injection.

That last test is particularly revealing. If adding unrelated historical context changes the result, the system may have memory capacity but not memory discipline.

From Memory Stores to Transition Architecture

The larger lesson is that AI systems operating across time should be designed around transitions rather than sessions.

A session is a user-interface boundary. It is not necessarily a meaningful unit of state.

The patient’s disease trajectory continues between scans. The dashboard’s operating contract continues between conversations. The machine continues accumulating wear after the maintenance chat closes. The customer account continues changing while the support agent is offline.

A production architecture should therefore ask:

What remains true when the interface disappears?

That information belongs in durable state.

It should then ask:

What new evidence is allowed to change that state?

Those inputs belong in the transition mechanism.

Finally:

Which traces merely document how the system once worked?

Those belong in logs, audits, temporary storage, or nowhere at all—not automatically in the next prompt.

The emerging principle is not that AI should always remember less in absolute terms. A baseline PET volume contains far more information than a short workspace specification. The principle is that the quantity of retained information should follow from its role in constraining valid futures.

Everything else is context-shaped clutter.

The Present Is Not the Transcript

The industry has spent several years expanding what models can fit into a context window. That work is useful. It should not be confused with deciding what deserves to be there.

$\Delta$-Diffusion shows that a future state can be generated more faithfully when the system is anchored to the correct subject-specific present and explicitly conditioned on the mechanisms of change.

Shared Selective Persistent Memory shows that an agent can perform better across sessions when it preserves the workspace contract and leaves the prior execution trace behind.

Together, they support a sharper definition of AI continuity:

A system remembers well when it preserves the constraints that make the next state valid—and forgets the rest before it becomes a habit.

The next generation of production AI will not be distinguished merely by how much history it can ingest. It will be distinguished by whether someone bothered to decide what the history means.

Cognaptus: Automate the Present, Incubate the Future.