Pulse instead of dump

Do not flood the runtime with memory. Connect it with fast, sparse, event-driven signals.

Three constraints, 1944

Most discussions of agent architecture start with models, tools, or prompts. A more useful starting point is three constraints that any system—biological or artificial—must satisfy if it is going to stay ordered, remember anything reliably, and keep running. Erwin Schrödinger laid them out in What Is Life?.

1. AveragingReliable behaviour at scale comes from large numbers. Individual events are noisy; the relative error shrinks as 1/√n.
2. High-barrier statesInformation that must persist cannot rely on averaging alone. A gene stays intact because the energy required to change it dwarfs the thermal noise around it. Schrödinger called the resulting structure an aperiodic crystal: ordered but non-repeating, able to store a code.
3. Open thermodynamic engineThe whole system imports free energy and exports entropy (heat). If that flow stops or becomes inefficient, order collapses.

The same physics in the stack

The statistical layer is pre-training and scale: more data and parameters produce more reliable generalisations, the way a large number of molecules produces a reliable gas law.

The stability layer is the discrete representations—tokens, embeddings, weights, and any external memory we attach. These are the aperiodic crystal. They work only while the barriers around useful states stay high.

The thermodynamic layer is compute and inference: tokens processed, energy spent, heat generated. An agent that constantly re-processes stale or irrelevant context is a cell with leaky mitochondria.

Users and developers of agents cannot change the first layer (the foundation model’s training run) or the raw hardware of the third. They can change the harness—the environment the model runs inside—and especially how that harness talks to memory.

Dumping is the wrong n

Current practice mostly ignores the constraints. We dump large slices of memory into the context window. That increases n in the wrong direction: more tokens, more noise, more averaging over irrelevance. It also burns energy on tokens the model did not need and lowers the effective barriers around the facts that actually matter. Hallucinations and “lost in the middle” are the predictable results.

This is the agentic form of streaming raw telemetry forever—the failure mode of the EEaaS to agents essay. There, the durable idea is that the cost of the next useful observation must fall while decision quality rises. Dumping memory is the opposite: observational overhead grows with history until history itself becomes a liability.

A pulse, then a surgical snippet

A better pattern follows directly from the three principles. Do not flood the runtime with memory. Connect the live harness to memory (local or cloud) with fast, sparse, event-driven signals. When the runtime needs something, it emits a compact pulse. Memory traverses only the relevant slice and injects a surgical snippet. The return signal can immediately queue the next likely traversal so the following context is already prepared.

The working set stays small. The statistical average the model performs contains less noise. The discrete fragments that arrive are closer to verified, high-barrier states. The energy cost per step drops because the runtime is not forced to re-read the entire history on every token.

This is not a new model. It is a different contract between runtime and memory: pulse instead of dump.

One concrete pulse

Imagine a long-running apply agent. The user asks: does this draft still match the xAI constraints we locked last Tuesday?

Dump: paste thirty-eight thousand tokens of chat, tool traces, and prior CVs into the window. The model averages over irrelevance. The locked constraint is somewhere in the middle.

Pulse: the runtime emits a compact tool-call signal, not a transcript.

retrieval key

apply/xai/constraints

verification flag

inject only if the fragment still hashes to the locked revision—a high-barrier check, not a vibe

prefetch

apply/xai/projects — the next likely traversal, already warming

Memory walks that slice, returns roughly 120 verified tokens, and queues the projects fragment. The working set stays small. The following tool call does not start cold.

Who this is for

The problem is interesting for developers and mid-sized labs precisely because the large labs can keep stretching context windows and paying the token tax. Everyone else is constrained by cost, latency, and the reliability of long-running agents. A clean pulsive protocol sits at the intersection of the two layers they can actually control—the harness, and memory.

Solving the signal design and the prefetch logic well would produce better agents without another 10× pre-training run.

Closing

The EEaaS to agents essay argued that intelligence stays viable only when the cost of the next useful observation falls while the quality of the decisions that observation enables rises. Memory is where that constraint becomes operational. Selective signals—Key Decision Indicators in that essay, pulses here—are the same move: report less, decide better.

Pulse is the traffic rule. A follow-up asks the prior question: what is allowed to become a snippet at all?

Pulse instead of dump. Keep the working set small, the barriers high, and the heat spent on tokens that can still change a decision.