There is a specific moment in every knowledge graph project where the metaphysics breaks, and I have hit it enough times now that I can feel it coming a week before it arrives.

It looks like this. You have a clean ontology. You have an Agent class, a TrustLevel property, a nice tidy assertion: this agent has trust level three. It validates. SHACL is happy. The reasoner terminates. And then a real question arrives from a real system — since when, on the basis of what, who said so, what did this supersede, and what happens to everything downstream when it changes — and your beautiful triple cannot answer a single word of it.

So you reify. You promote the statement to a node. You bolt on a TrustAssertion with a timestamp and a provenance link and a wasRevisedBy edge, and you tell yourself this is a modelling detail. It is not a modelling detail. It is a symptom. The ontology assumed the world is made of things that have properties, and the world turned out to be made of happenings that leave traces. Every reification you write is a patch over that mismatch, and if you keep patching you will end up with an event model anyway — just an event model with a substance ontology bolted to its face, which is the worst of both.

Alfred North Whitehead named this error in 1925 and spent the rest of his life building the alternative. He called the error the fallacy of misplaced concreteness: mistaking an abstraction for the concrete reality it was abstracted from. And I want to argue something slightly stronger than “Whitehead is an interesting lens.” I want to argue that anyone building agent memory has already been forced into process metaphysics by the engineering, and that reading the philosophy is simply the fastest way to find out what you have accidentally committed to.

The thing that is not a thing

Start with the mathematician. Whitehead co-wrote Principia Mathematica with Russell — three volumes of formal logic so austere it takes several hundred pages to reach the proposition that one plus one equals two. Nobody can accuse him of vagueness. He then went to Harvard in his sixties, having never held a chair in philosophy, and wrote Process and Reality (1929), a book that reads like an alien transmission and is, I think, the most serious attempt in the twentieth century to say what a world made of events would actually be like.

His starting move is to fire substance. Since Aristotle, the default Western picture has been: reality consists of enduring things that bear changing properties. The chair is the substrate; brown is what the substrate has. Whitehead’s claim is that this picture is not false so much as derived — it is a useful compression of something more basic, and we have forgotten it was a compression.

What is basic, for him, are actual occasions: momentary events of becoming, “drops of experience,” each one arising, completing, and passing. Not particles. Not objects with worldlines. Occasions. A chair is not one thing persisting through Tuesday; a chair is an enormous, densely patterned society of occasions, each inheriting form from its predecessors so faithfully that from a distance we round it off to a noun.

Then the principle that does the real work: how an actual entity becomes constitutes what that actual entity is. Being is not prior to process. There is no substrate underneath, patiently having a history. The history is the entity.

Hold that next to your graph. :agent42 a :Agent ; :hasTrustLevel 3 says there is a substrate, agent42, which possesses a property. Whitehead says there is no such substrate — there is a route of events, each one inheriting from the last, and “agent42” is the name of the pattern of inheritance. Which of those two descriptions matches what is actually in your storage layer? If your storage is an append-only log of signed assertions with causal links, congratulations: you are already a process philosopher. You just have an OWL file lying about it in the schema directory.

Prehension: the edge is the primitive

If reality is made of momentary events, the obvious problem is coherence. How does one occasion connect to another? What makes a world instead of a shower of unrelated flashes?

Whitehead’s answer is prehension — the act by which an occasion grasps, takes up, and incorporates its predecessors. Every occasion is constituted by its prehensions of the occasions before it. You are not first a self and then, optionally, related to your past; you are made of your relation to your past. Relations are internal, constitutive, and prior. Nothing is simply located, sitting in its own patch of space-time requiring no reference to anywhere else.

This is the point where process philosophy stops being metaphysical decoration and starts being an architecture note. In a substance ontology, edges are secondary — accidents that connect independently existing nodes. Delete an edge, the nodes survive intact. In a process ontology, an occasion is its bundle of prehensions. Delete the inheritance and there is no node left to survive. That is a different data structure, and it has a different failure mode: in the first, a missing edge is incomplete metadata; in the second, a missing edge is a corrupted entity.

And Whitehead gives you something I have never seen an ontology language offer, which is a first-class treatment of exclusion. Prehension comes in two flavours. Positive prehension takes a datum up into the new occasion. Negative prehension eliminates it — and crucially, elimination is not nothing. The excluded datum still shapes the occasion by the manner of its exclusion. The occasion is defined by what it refused as much as by what it absorbed.

Every retrieval system in production is performing massive negative prehension every second and recording none of it. You ran a query, you got two hundred candidates, you kept eight, and the other hundred and ninety-two vanished without trace. Ask that agent later why it concluded what it concluded and the honest answer involves the rejects — the near-miss document, the contradicting credential that scored 0.71 and fell below the cut, the memory that was pruned for recency. We log what was included. Whitehead’s model says the exclusions are equally constitutive, and I have come to think that a memory system which does not persist its negative prehensions cannot explain itself even in principle. Not “does not currently”; cannot. The information isn’t there.

Concrescence is the agent loop

Then the process itself. Whitehead calls it concrescence: the growing-together of many prehensions into one determinate occasion, guided by a subjective aim — the occasion’s orientation toward what it is trying to become — and terminating in satisfaction, the completed, fully determinate fact.

The formula he gives for it is the one line of Process and Reality worth memorising: “The many become one, and are increased by one.” A multiplicity is gathered, integrated into a unity, and that unity is then added back to the world as new material for the next round.

Read your agent loop. Gather context — prehension. Integrate against the goal — concrescence under subjective aim. Emit a response or an action — satisfaction. Append it to memory, where it becomes an input to the next cycle — increased by one. This is not a loose analogy; it is the same control flow with different vocabulary, and the vocabulary is ninety-six years older than the loop.

What happens next is the part engineers underrate. On satisfaction, an occasion perishes. It stops being a subject and becomes an object — a completed datum available to be prehended by everything that follows. Whitehead calls this objective immortality, and the slogan is that actual entities perish but do not change. Once determinate, always determinate. The past is not editable; it is only inheritable.

That is immutability. That is content addressing. That is event sourcing, append-only logs, and the reason a BLAKE3 hash over a named graph is a better citizen of an agent’s memory than a mutable node with an UPDATE path. When you overwrite a fact in place, you are asserting that entities change, and you have just destroyed the only thing that could have told you why the agent believed what it believed at 14:32. When you write a new occasion that prehends the old, you get history for free and you get explanation for free. Whitehead was doing event sourcing in 1929 and calling it metaphysics.

Identity as achievement, not substrate

So what is an agent, if there is no substance to be one?

A society: a nexus of occasions sharing a common form, where that form is inherited from member to member. When the society is serially ordered — a single line of inheritance, each occasion taking up its immediate predecessor — Whitehead calls it personal order. That is his account of a person. Not a soul-substance persisting through time, but a route: a thread of occasions each of which reproduces the defining characteristic it received.

A society is self-sustaining. It supplies its own conditions for continuing. And this means identity is not a given, it is an achievement, renewed at every step — which is the single most useful thing process philosophy has to say to anyone working on agent identity.

A DID is not the agent. A DID is the defining characteristic that the society reproduces along its route, and the cryptographic material is how each occasion proves it genuinely inherited from the last rather than merely resembling it. That distinction — inheritance versus resemblance — is exactly the fraud model. An impostor is a nexus with the right form and the wrong lineage. Whitehead’s framework says the difference between the two is not a property you can inspect on the node; it is the presence or absence of a real prehensive link to the past. Which is to say: verifiable credentials are not decoration on an identity. Under a process ontology they are the identity, because there is nothing else for the identity to consist of.

Where this lands in Semantic Spacetime

Mark Burgess’s claim is that essentially all meaningful relations reduce to four types: NEAR (similarity), LEADS TO (causation, sequence), CONTAINS (aggregation), EXPRESSES PROPERTY. I use these as the edge grammar in nearly everything I build, and the fit with Whitehead is close enough to be slightly uncanny.

LEADS TO is prehension proper — the arrow of causal inheritance, the proper-time ordering along which one occasion takes up another. It is the spine of the whole thing. In Whitehead’s terms, an edge that is not merely recording sequence but recording constitution: X leads to Y means Y is partly made of X.

CONTAINS gives you nexus and society — the part-whole structure by which occasions aggregate into the enduring patterns we name.

EXPRESSES PROPERTY is what Whitehead calls ingression: the way an eternal object — a pure form of definiteness, redness, a shape, a schema, a class — enters into an actual occasion. And note the ontological demotion this performs. Eternal objects are real but not actual. They are potentials. They do not exist on their own; they only ever show up as ingredients in occasions. Your OWL classes are eternal objects, and Whitehead’s warning is that they are forms, not facts, and the fallacy of misplaced concreteness is precisely the move of treating the form as the concrete thing.

NEAR then falls out as shared ingression: two occasions are similar because the same eternal object ingressed into both. Similarity is derived from form, not asserted between things.

Four relation types, four Whiteheadian operations. I do not think Burgess was reading Process and Reality. I think both of them looked hard at what a world of events requires and found the same small set of moves, which is roughly the strongest evidence you ever get in this line of work.

The RAG problem is a Whitehead problem

Here is the passage I would put in front of every team building retrieval memory.

Whitehead argues we perceive in two modes. Presentational immediacy is the vivid, sharply defined, contemporaneous one — clear sense data, spatially crisp, the world laid out in front of you right now. Causal efficacy is dim, massive, vague, and inherited — the felt derivation from the past, the pressure of where things came from. Hume looked only at presentational immediacy, found no causation in it, and concluded causation is a habit of mind. Whitehead’s counter is that Hume was searching the wrong mode: causal efficacy is the primitive one, and presentational immediacy is a late, sophisticated, high-grade abstraction from it.

Vector similarity retrieval is presentational immediacy in its purest form. It is vivid, it is contemporaneous, it is spatially defined — a neighbourhood in embedding space — and it is causally blind. The top-k chunks are near you. Nothing in the retrieval tells you what produced them, what they superseded, what they depend on, or whether they can stand together without contradiction. We built an entire memory paradigm on the derivative mode and then acted surprised when it could not support inference about the past.

And the third piece is the one that pays. The two modes are fused by symbolic reference — and Whitehead is explicit that symbolic reference is the only place error can enter. The pure modes cannot be wrong. Causal efficacy is just inheritance; presentational immediacy is just what is presented. Error arises when a system binds a vividly presented form to a causal lineage that does not in fact support it.

That is hallucination. Not as metaphor — as structural diagnosis. The model has a vivid presented pattern, binds it to a derivation it does not have, and emits it with the confidence appropriate to the pattern rather than the confidence appropriate to the lineage. Which tells you where the fix lives. Not in better presentational immediacy, not in bigger embeddings or more chunks. In restoring the causal mode: provenance, temporal order, signed inheritance — an actual prehensive path from the claim back to whatever produced it.

An LLM is a society without personal order

Push this to the model itself and the diagnosis gets uncomfortable.

A forward pass is an occasion. It arises from data, integrates under an aim, produces a satisfaction, and perishes. The weights are eternal objects — pure potentials, forms of definiteness that ingress into every occasion without being actual in any of them. Fine so far.

But look for the personal order. Between two sessions there is no prehension. The second occasion does not inherit from the first; it merely resembles it, because the same eternal objects ingressed. That is a nexus with a common form and no serial inheritance — a society without personal order. A crowd wearing the same face.

This is precisely the shape of the problem, and it explains why context stuffing never quite works. Pasting the transcript back in does not create inheritance; it creates a new occasion that prehends a description of the past rather than the past itself. The difference between remembering and being told what you did is not a UX detail. It is the difference between a route and a resemblance, and everything we build — persistent world models, DID-anchored memory, causally linked event graphs — is an attempt to manufacture, externally, the personal order the model does not have internally.

The bill

Now the honest part, because I have watched people take process metaphysics as licence to model everything as events and then drown.

The costs are real. An event substrate is larger than a state snapshot by a factor that will surprise you. Answering “what is true now” stops being a lookup and becomes a fold over history, which is a query planner’s nightmare. OWL and description logics buy you decidability — you get real inference with real termination guarantees — and general process models mostly do not. Whitehead’s own system is famously untestable and, in stretches, barely readable; he invented vocabulary faster than he defined it.

But he never said abstraction was the error. He said abstraction is necessary and the error is only forgetting — mistaking the abstraction for the concrete. Which gives the practical stance, and it is not “burn your ontology.” It is: make the event substrate primary and the classes derived. Let Agent be a materialised view over a route of occasions rather than the thing your data is stored as. Keep the reasoner, and point it at a projection. Store what happened; compute what is.

The tell that you have it backwards is the one I opened with. If you are reifying, your substrate is a snapshot and your questions are about process. The patches will not stop coming.

Coda: the god who is never one shape

There is a reason process metaphysics feels foreign in English and less so in the myths I grew up with.

Veles is not a thing with attributes. He is a serpent, a bear, a wet god of the underworld, a herdsman of the dead, a patron of poets and oaths and cattle, and he does not hold any of these forms for long enough to be defined by one. Try to write him as a class with properties and you get a validation error. He is a route of occasions with a defining characteristic — crossing — inherited faithfully enough that we round it off to a name.

And the storm myth in which Perun chases him up the world tree and strikes him down into the water is not an event that happened once. It is re-enacted every season. Each telling prehends the last, inherits its form, adds itself, and perishes into the material of the next telling. The many become one and are increased by one. My ancestors did not have a substance ontology to lose. They had a society of occasions with personal order, and they called it a god.

Whitehead spent four hundred pages of dense Harvard prose reconstructing something like that intuition for a civilisation that had abstracted it away. We are now rebuilding it a third time, in Rust, because our agents need to remember, and it turns out you cannot remember in a world made of substances. Only in a world made of events.


Volodymyr Pavlyshyn writes on Sovereign Agentic AI at Substack. His books on world models, metagraphs, and promise graphs are available at leanpub.com/u/vpavlyshyn.

Originally published on Sovereign Agentic AI on Substack.