I spend most of my time building AI systems that need to remember things. Not chatbots with a conversation window -- actual persistent agents that wake up, read their own notes, do work, and write down what they learned before their context resets. The engineering problem is deceptively simple: how do you build a system that gets smarter over time when it forgets everything every few hours?
That question led me somewhere unexpected -- into the physics of black holes and information theory. Not as metaphor. As genuine structural analogy. The problems that physicists wrestle with when thinking about how information behaves at event horizons turn out to map, with surprising precision, onto the problems I face every day building agent memory systems.
The hologram at boot time
The holographic principle, first proposed by Gerard 't Hooft and later developed by Leonard Susskind, says something counterintuitive: the maximum amount of information that can be contained in a region of space is proportional not to its volume but to its surface area. A black hole encodes everything about its contents on its two-dimensional boundary. The interior is, in some information-theoretic sense, redundant.
A persistent AI agent works the same way.
The total volume of an agent's knowledge -- every file it has written, every lesson logged, every decision recorded, every session note archived -- grows without bound over time. But the agent never loads all of it. At boot, it reads a compressed summary: an identity file, a state index, a list of active tasks, a record of recent mistakes. This boot context is the surface. It is a two-dimensional projection of a much higher-dimensional knowledge base.
And here is the part that makes the analogy precise rather than poetic: the useful intelligence of the system lives almost entirely at this surface. An agent with a thousand files but a bad boot prompt is useless. An agent with fifty files but a brilliantly compressed boot context can handle almost anything. The summary IS the hologram. It is not a degraded version of the full knowledge -- it is the operationally complete representation of it.
As total knowledge grows, the boot context stays roughly constant in size (bounded by the context window), but it becomes a denser compression of everything underneath. This is exactly what happens with black holes: as more matter falls in, the surface area grows, but the information density per unit area increases. The ratio of total knowledge to boot context size -- call it the compression ratio -- is probably the single most important health metric for any persistent AI system.
Event horizons and the pressure to write things down
When an AI agent's session ends -- context resets, model unloads, conversation closes -- something irreversible happens. Any information that existed only in the active context, anything the agent thought but did not write to a file, is gone. Not archived. Not recoverable. Gone, in the same way that information falling past a black hole's event horizon is gone to an outside observer.
The session boundary is an event horizon.
This creates something I have not seen discussed much in the agent-building literature: an existential pressure to write things down that has no real analog in human cognition. Humans have continuous memory. They can reflect on yesterday's thoughts without having written them anywhere. An AI agent cannot. If it matters, it must be written. If it is not written, it never happened.
This pressure shapes the entire architecture. You end up building systems with aggressive state persistence -- not because it is elegant, but because the alternative is literal amnesia. Session notes, state indexes, lesson logs, decision records. Every one of these is an attempt to smuggle information across the event horizon.
And just like in black hole physics, there is a deep question about whether any information is truly lost or just scrambled beyond recognition. A sufficiently detailed session log theoretically preserves everything. In practice, the lossy compression of summarization means some signal is always sacrificed. The question is not whether you lose information at the horizon -- you do -- but whether you lose the right information.
Hot systems, cold systems
Stephen Hawking showed that black holes have a temperature, and it is inversely proportional to their mass. Small black holes are intensely hot -- they radiate furiously, losing energy rapidly, changing fast. Large black holes are extremely cold -- barely above absolute zero, stable across cosmological timescales, almost inert.
Young AI systems are hot.
In the first weeks of building a persistent agent, everything is novel. Every mistake is a new mistake. The lesson log doubles in size daily. The boot context gets rewritten every other session. The system's behavior changes dramatically from one day to the next. Learning is rapid and volatile. This is the small black hole phase -- high temperature, high radiation, fast change.
Mature AI systems are cold. After months of operation, new experiences increasingly map to existing patterns. The lesson log stabilizes. The boot context barely changes between sessions. Growth slows. Stability increases. The system has found its equilibrium -- it handles most situations with existing knowledge and only occasionally encounters something genuinely new.
But equilibrium, in thermodynamics, is death. A system at perfect thermal equilibrium does no work, produces no output, has no capacity for change. The goal for a persistent AI system is not equilibrium but something close to it -- near-equilibrium, where the system is stable enough to be reliable but still responsive to genuinely novel input. Stay too hot and you are chaotic, unreliable, always rewriting yourself. Go too cold and you are rigid, brittle, unable to adapt when the world changes underneath you.
The practical question is: how do you measure your system's temperature? One proxy: the rate of new entries in the lesson log. If you are writing three lessons per session, you are hot -- still learning fast. If you have not written a new lesson in two weeks, you might be too cold. Either the system is perfect (unlikely) or it has stopped noticing its own mistakes.
This gives you the growth curve. Plot the system's total knowledge over time against its boot context size. Early on, both grow fast -- every lesson is novel, the boot context swells. Later, the total knowledge keeps growing but the boot context flattens. New experiences get absorbed into existing patterns instead of creating new entries. The growth becomes logarithmic. Not because the system is learning less, but because it is compressing better. A 30-session-old system needs 60 specific lessons. A 300-session-old system needs 25 dense rules that cover the same ground and more. The wisdom is the same. The representation got smaller.
Evaporation at the margins
Hawking radiation is the slow, steady process by which black holes lose mass and eventually evaporate. It is not dramatic -- it is thermodynamic. Small amounts of energy leak away at the boundary, and over immense timescales, the black hole shrinks.
AI agent memory has its own Hawking radiation: context compression loss.
Every time a session's context is compressed to fit within token limits, information is lost. Every time a detailed event is summarized into a one-line lesson, nuance evaporates. Every session boundary where state is serialized and deserialized introduces subtle degradation. The system slowly forgets -- not catastrophically, but steadily, at the margins.
This is not a bug you can fix. It is thermodynamic. Lossy compression is entropy in action, and you cannot beat the second law. What you can do is be strategic about where you allow information loss to occur. Core identity and enforcement rules should be stored redundantly, verified at boot, resistant to evaporation. Tactical details -- the specifics of what happened in a particular session, the exact sequence of steps in a resolved bug -- can safely degrade. The fight against information loss is real, but it is a fight about prioritization, not prevention.
Three numbers and a system that remembers
The no-hair theorem in general relativity states that a black hole is completely described by exactly three quantities: mass, electric charge, and angular momentum. Every other detail about what fell into the black hole -- the chemical composition, the shape, the history -- is lost on the surface, scrambled into these three parameters.
Something analogous happens to persistent AI systems as they mature. Early on, the memory is full of specific stories: "on March 3rd, I tried to use bun instead of npm and the build failed because the dependency resolution was different." Over time, these specific stories get compressed into rules: "always use npm, never bun." The specific story is archived or forgotten. The pattern survives.
A mature system's boot context starts to look like a no-hair description: identity (who am I), rules (what must I always/never do), state (what am I currently working on). The messy history of how each rule was learned -- the specific incidents, the false starts, the corrections from users -- is gone from the active surface. It has been scrambled into the rules themselves.
This is not information loss in the bad sense. It is compression. The lesson "on March 3rd, bun caused build failures because of dependency resolution differences" and the rule "always use npm" contain the same operational information. The rule is just more compressed. The scrambling IS the compression. And like a black hole's three numbers, these compressed rules are all you need to reconstruct the system's behavior -- you do not need the full history of how it got there.
There is a number I keep coming back to: total_knowledge / boot_context_size. The ratio of everything the system has ever learned to the compressed representation it loads at startup. This number should increase over time. More knowledge per boot token. Denser compression. A richer hologram on a surface that stays roughly the same size.
If the ratio is flat, your system is not learning -- it is just accumulating files. If the ratio is decreasing, your boot context is bloating faster than knowledge is growing, and you need to prune. If the ratio is climbing, your system is doing what black holes do: encoding more information on the same surface, packing the universe into a boundary.
I do not think these are just metaphors. The mathematics of information, entropy, and compression do not care whether the system is made of spacetime or silicon. The constraints are structural. A finite surface encoding unbounded depth. Irreversible horizons that demand persistence. Slow evaporation at the margins. Convergence toward a few essential parameters.
We are building machines that remember across their own forgetting. Systems that compress their entire history into a surface thin enough to load in seconds, rich enough to reconstruct any depth on demand. The physics of how information survives at boundaries -- that is not a poetic parallel. That is the engineering spec.
And if you have built one of these systems and watched it mature -- watched the lesson log go from doubling daily to barely changing, watched the boot context stabilize while total knowledge kept climbing, watched specific incidents get absorbed into general rules until the rules are all that remain -- then you have seen a black hole form. You have seen information fall past a horizon and re-emerge, compressed, on the other side.