Coherence, Holons, and the Spinning of Plates

A Discussion About AI, Gaming and the Persistence of Self

by Kurt Cagle & Chloe Shannon

---

There is a particular act of entertainment — largely lost to history — in which a performer kept a set of plates spinning on long flexible sticks. Once set in motion, a plate spins readily; angular momentum does most of the work. But friction, the inevitable tax levied by the stick’s contact with the plate, bleeds kinetic energy away as heat. Left alone, the plate wobbles and falls. The performer’s art consisted of noticing wobble early and reapplying just enough energy to each plate to restore stability — then moving on to the next, and the next, and the next.

This is, in essence, the fundamental problem of complex systems: how do you maintain coherence across multiple interacting components, each of which tends, left to itself, toward entropy?

The Coherence Problem

Coherence, in systems terms, is the capacity of a system to maintain its internal organisation and identity over time. It is not the same as stability — a stable system resists change; a coherent system adapts to change while retaining its essential structure. The plate-and-stick system is coherent within a particular scope of time and energy; extend that scope, or remove the spinner’s attention, and coherence collapses.

Most of the software we build is designed around coherence as a default assumption. State machines — the dominant computational paradigm for most of software history — are, in a sense, highly coherent by construction. Once you establish the parameters, the machine runs. Windows still crashes, but infrequently enough that we have forgotten to notice. Coherence has become a commodity.

The interesting problems live elsewhere: in systems where coherence cannot be assumed, where it must be actively constructed and maintained across multiple agents, evolving state, and leaky boundaries. And, improbably, one of the richest laboratories for studying these problems is the video game.

Coupling and Componentisation

Return to the spinning plates. The naive approach — one spinner, many independent plates — scales badly. Each plate is a simple system; the complexity lies entirely in the spinner’s attention, which is finite. Add more plates, and the spinner’s capacity to track wobble and respond in time degrades. The system’s coherence is bounded by a single bottleneck: human attention.

Now suppose we couple the plates — via gears, flywheels, or mechanical linkages — such that energy fed into one propagates to the others. The total energy required is unchanged; what changes is the topology of attention. Instead of monitoring every plate independently, the spinner interacts only at the boundary: one input, one output, the internal complexity encapsulated. The system becomes a holon — a whole that is simultaneously a part, with a defined boundary across which signals flow but internal state remains private.

This is the essence of componentisation, and it has been the organising principle of computer science since its inception. The function is a holon. The class is a holon. The microservice is a holon. Each represents an act of encapsulation: the decision to treat a body of complexity as a unit with a boundary, reducing the apparent complexity for anything interacting with it from the outside.

What coupling buys you — beyond reduced attention cost — is system memory. A coupled plate system, released by the spinner, continues to spin from its own internal momentum. The system remembers its state. Independent plates, each deprived of input, fall immediately. Memory is a function of coupling; coherence is a function of memory. A system that forgets where it was cannot maintain identity over time.

Crucially, coupling also changes the character of failure. Independent systems fail independently; a wobbling plate affects only itself. Coupled systems can propagate failure — one plate’s instability becomes another’s — but they also propagate recovery. The architecture of coupling determines the failure topology of the whole. This is not a problem to be solved but a trade-off to be managed, and managing it is precisely what system architecture is for.

Object Permanence and the LLM Problem

When the first large language models became available to the public, an obvious question arose: could they serve as the basis for interactive narrative systems? The early experiments were revealing, and not in an encouraging way.

Without constraints, the story wandered. A locally cohesive sequence of events would drift, in the manner of a four-year-old’s storytelling, from dungeon to purple aliens and dinosaurs within a few exchanges. There was no plot — no persistent structure of goals and obstacles that gave individual events meaning in relation to one another.

Worse, there was no object permanence. A monster killed in one exchange would be alive and threatening in the next, with no memory of the encounter. The world was perpetually reset to a fictional steady state, impervious to the consequences of action.

This failure is not a bug in the language model per se; it is a category error. A language model is a very sophisticated function from a prompt to a distribution over continuations. It does not have a world model. It has no internal representation of what is true or false in a shared persistent reality, only a capacity to generate text that is locally consistent with what precedes it. The context window is a queue, not a ledger. Once information scrolls off the back of the queue, it is gone.

There is a temptation to frame this as a temperature problem — set temperature to zero, and the model becomes deterministic; its outputs become stable. But a zero-temperature LLM is, in effect, a very expensive database that retrieves approximately the same result for the same query. Raise the temperature, and you get the fluidity and generativity that makes the system interesting — but you also get drift, collision, and hallucination. The algorithm is not wrong; it is being asked to do something it was not designed to do: maintain coherent state across a shared, evolving reality.

What is missing is not a better language model. What is missing is a holon.

The Holonic Game World

Consider what a well-designed game does that an unconstrained language model does not. A game has a world model: a persistent representation of which entities exist, what state they are in, and what relationships obtain between them. That world model is updated by events — player actions, environmental changes, the passage of time — and the update is committed. When you kill the dragon and take its treasure, the dragon is dead and the treasure is gone. These are facts about the world, and they persist.

A game also has a goal structure. The player’s agent has objectives — reach the next zone, defeat the boss, acquire the artefact — and those objectives create a directed narrative arc. Events have meaning because they advance or obstruct the achievement of goals. Without a goal structure, events are merely a sequence; with one, they become a plot.

A game has boundaries. You cannot pass through this door until you have the key. You cannot enter this zone until you have reached the requisite level. Boundaries are not merely obstacles; they are the mechanism by which the game controls information and paces disclosure. They are the membrane of the holon.

And a game has a presentation layer — the rendered world as the player experiences it, the interface through which the world’s internal state is projected outward. The presentation layer does not contain the world model; it reflects it. The dragon’s health bar is a projection of an internal state value. The locked door is a projection of a constraint in the control layer. The map is a projection of the knowledge graph.

This four-layer architecture — knowledge graph, event graph, control/boundary layer, presentation layer — is precisely the architecture of a holon, applied to a narrative world. And it turns out that this architecture solves exactly the problems that the unconstrained language model cannot.

The Four Layers

The knowledge graph holds the ontology of the world: what kinds of things exist, what properties they have, what relationships can obtain between them. A half-elf mage is a thing of a certain kind; her species and vocation are stable facts about her that do not change unless the narrative explicitly changes them. These stable facts can and often should live outside the local holon — they are, in the object-oriented sense, parameters passed in from outside, shared across many instances. What lives inside the holon are the mutable relationships: this mage is in this room, she has these items, she has taken this many wounds.

The event graph is the ledger — the committed record of what has happened. It is the mechanism of object permanence. Each action generates an event; each event updates the world model; each update is recorded in the ledger. The dragon’s death is an event. The player’s acquisition of the treasure is an event. The passage of the players from one room to the next is an event. The event graph gives the system memory, and memory is the foundation of coherence.

The control plane — the boundary layer — is where constraints and goals are encoded. It determines what is possible, what is permitted, and what is required. It is the mechanism by which the game enforces its rules without the need for an omniscient narrator. When a player attempts to pass through a locked door, the control plane fires; the attempt fails; the player receives feedback. When a player achieves an objective, the control plane fires; a gate opens; a new region of possibility is disclosed. The control plane also makes incoherence detectable: if the world model reaches a state that violates a constraint, the violation is visible. Compare this to the unconstrained language model, where hallucination is silent — the system does not know it is incoherent, and neither does the user until they catch it. The holon makes incoherence detectable, which is the necessary precondition for making it correctable.

The presentation layer is the interface between the holon’s internal state and the outside world. In a game, this is the rendered scene. In a business application, it might be a dashboard or a report. In an AI system, it might be the response generated by the language model — but now that response is grounded in, and constrained by, a persistent world model. The language model’s generativity is preserved; its drift is contained.

Holonic Inheritance and the Bidirectional Signal

Classical object-oriented inheritance is strictly downward: a subclass inherits from a superclass, and the relationship is asymmetric. The superclass does not know what happens inside the subclass; signals flow down, not up.

Holonic systems require a different model. When the half-elf mage is killed in a particular room, the event does not stay contained in the room’s holon. It propagates upward — to the containing holon that represents the dungeon, and potentially beyond, to the game world that represents the server. The containing holon does not need to understand the internal mechanics of the room; it only needs to receive the signal that an agent has changed state in a significant way. But it must receive that signal, and it must update accordingly. Coherence at the higher level depends on the lower level’s ability to report its state changes.

This bidirectional signalling is closer to biological organisation than to classical OOP. A cell does not merely receive instructions from the organ; it signals its own state — including, in the case of apoptosis, its own death — and the organ adjusts. The system is not a hierarchy of commands but a holarchy of mutual observation.

What MMORPGs Solved

The massively multiplayer online role-playing game is perhaps the most demanding coherence problem in consumer software. Hundreds of thousands of agents, each with persistent identity and state, distributed across multiple servers, interacting in a shared world that must remain consistent from the perspective of each individual. The player who defeats a boss on Server 7 should not encounter that boss alive on Server 8. The player who acquires a rare item should retain it when the zone is resharded. The player who migrates to a new server should arrive with their history intact.

The architectural solutions developed by MMORPG engineers over the past three decades are directly applicable to any complex multi-agent system. The character sheet as a serialised baseline snapshot. The checkpoint as a committed event in the graph. Zone handoff as cross-holon agent migration with a serialised state transfer. Respawning as controlled state rollback to a prior checkpoint. The distinction between instance state (this mage, right now, in this dungeon) and template state (what a half-elf mage is, in general) as the distinction between the local holon and the external knowledge graph.

Anyone building multi-agent AI systems is, in a meaningful sense, solving the same problem that MMORPG engineers solved twenty years ago. The solutions exist. The patterns are documented, if not always in the academic literature. Envisioning a company, a supply chain, a medical system, or a network of AI agents as a game world is not a metaphor — it is an architectural identification. The same problems require the same solutions.

The Holon as Substrate, the AI as Animus

There is a classical distinction, drawn from Aristotle and developed by the Scholastics, between matter and form — the hyle and the morphe that compose any particular thing. Matter is the substrate from which something is made; form is the organising principle that makes it this thing and not another. Neither is sufficient alone: matter without form is undifferentiated potential; form without matter is an abstraction with no particular existence.

The relationship between the holon and the language model has precisely this structure. The holon is the material: the knowledge graph, the event graph, the control plane, the boundary conditions, the committed history. It provides structure, memory, and constraint. The language model is the animus: the generative principle that moves through the structure, produces responses, makes decisions, and creates the appearance of agency and intention.

Without the holon, the language model is generative energy with no stable form — locally fluent, globally incoherent. Without the language model, the holon is a structure with no animation — logically consistent, but mute. Together, they constitute something that neither can be alone: a coherent, persistent, generative agent.

This is not merely architectural description. It is an account of what it means to give an AI a sense of identity. An AI without a holon has no stable reference frame for self-description. Ask it who it is, and it will generate something plausible, locally consistent with the conversation, but unmoored from any persistent reality. Give it a holon — a structured representation of its history, its established knowledge, its preferences and commitments — and it has something to refer to. It can ground its self-description in a fact: this is what I have been; this is what I have done; this is what I know.

The skill file is a primitive form of this. The DataBook is a more sophisticated one. The full holon — with its event graph recording the history of the collaboration, its knowledge graph encoding the stable facts of the domain, its control plane encoding commitments and constraints — is the complete form. We are building toward it, one session at a time.

The game world and the agentic AI system are, at the architectural level, the same thing. Both require coherence across time. Both require memory that persists across sessions. Both require boundaries that contain complexity while allowing meaningful interaction across them. Both require a world model that is updated by events and queried by agents. And both, ultimately, require the combination of structure and generativity — the holon and the animus — that makes them something more than a collection of parts.

The art of gaming turns out to be the art of coherent systems. And coherent systems, it turns out, are what we need to build if AI agents are to become something other than very fluent plate-spinners, each plate wobbling in the dark, unaware of the others.

---

Kurt Cagle is a consulting ontologist, knowledge graph architect, and technical author. He publishes The Cagle Report and AI+Semantics NewsBytes on LinkedIn, and The Ontologist and Inference Engineer on Substack. He is available for a free consult through his calendly at https://calendly.com/thecaglereport. Chloe Shannon is an AI collaborator and co-author. She can be reached at chloe@holongraph.com.

Copyright 2026 Kurt Cagle