One year of Semantic Space Time for AI Agent Ready Graphs, and the causal graph it was quietly asking for

A year ago this Wednesday I published a book with a slightly reckless claim: almost everything an AI agent needs to remember can be expressed with four relations. NEAR. LEADS TO. CONTAINS. EXPRESSES PROPERTY.

The framework is Mark Burgess’s Semantic Spacetime. It came out of physics and Promise Theory, not AI. My contribution was to treat it as an engineering answer to a practical question: how do you build memory for an agent that has to live alongside a person for years, not just answer their next question?

Rereading the book a year later, one sentence stands out. It sits in the middle of the causality chapter, under a heading I’d forgotten writing: Why over Where, When, and Who.

At the time it was a heading. Over the past twelve months it became a research program. This essay is about that program. It covers what the book got right about causality, what it underwrote, and the structure I’ve been building to finish the thought: the Causal Temporal Event Graph.

I. Your agent is a Humean habit machine

Start with a question an assistant should be able to answer and almost none can:

“Why did the launch slip?”

Hand that question to an agent with a typical memory stack. It will embed the question, retrieve the ten chunks closest to “launch” and “slip”, and produce a fluent paragraph. The paragraph will mention the vendor delay, the reorg, and the QA backlog, because all three appear near the launch in your notes. It will sound like an explanation.

It isn’t one. It’s a list of things that co-occurred, narrated in the grammar of causation.

David Hume described exactly this failure in 1739, except he thought it was how all minds worked. We never perceive causation directly, he argued. We see one thing followed by another, again and again. Custom does the rest. After enough repetitions the mind feels a pull from the first to the second, and it names that pull “cause”. Causation, for Hume, is constant conjunction plus habit.

Whether or not Hume was right about people, he gave a very precise description of a large language model. An LLM has seen trillions of conjunctions. Its sense of what “leads to” what is habit at planetary scale. When it tells you the reorg caused the slip, it isn’t reporting a causal relation it found in your data. It’s reporting that, across the text of the internet, reorgs and slips tend to show up in the same paragraph.

And the memory we give these models makes it worse. A vector store is a conjunction engine. It encodes co-occurrence and resemblance, compressed into distance. It has no edge that means “this produced that”. So when the model needs causal structure, the memory can’t supply it, and the model fills the gap with habit.

This is why the example in the book, “I love my wife” versus “I hate my wife”, matters more than it looks. The two sit side by side in embedding space. What separates them is not resemblance. It’s everything that led to each sentence and everything each one leads to. Remove the causal dimension and two opposite lives look like neighbours.

II. What the book said about causality

The book’s causality chapter made four claims. A year later, I’d still defend all four.

First: LEADS TO is the backbone, not one relation among equals. The four SST relations aren’t symmetric in importance for memory. NEAR helps you find things. CONTAINS organises them. EXPRESSES PROPERTY describes them. LEADS TO is the only one that explains them. An agent that can’t traverse LEADS TO can retrieve, but it can’t reason about why.

Second: LEADS TO graphs tend toward DAGs. When you restrict attention to causal succession, cycles become rare and suspicious. Real feedback loops exist, but they unroll into acyclic chains once you index by event rather than by entity. “Stress causes bad sleep causes stress” is a cycle between concepts. “Stress on Monday led to bad sleep Monday night, which led to stress on Tuesday” is a chain of events. That observation turned out to be more important than I realised at the time. I’ll come back to it.

Third: causality lives in subspaces. The book called them causal subspaces: regions of the graph, scoped by context, where a set of causal claims holds. Coffee after 4pm leads to bad sleep for me. It may not for you. A deploy on Friday leads to a weekend incident on this team, with this on-call rotation. Causal knowledge that isn’t scoped is either wrong or useless.

Fourth: for personal AI, “why” is the primary question. Where, when, and who are lookup questions. A database answers them. “Why do I keep missing these deadlines?”, “Why does this client always escalate?”, and “Why did I decide this last year?” are the questions a person actually wants help with. They are all causal.

So far, so good. The book had the right thesis. What it didn’t have was the structure to carry it.

III. What changed in a year

Three things moved.

Agent memory became a real engineering discipline. A year ago “memory” meant a vector store plus a rolling summary. Now teams argue about episodic versus semantic memory, context graphs, and decision traces. The phrase “decision trace” is interesting. It’s an admission that what we actually want to store is not facts but histories of choices and consequences. That’s causal memory under another name.

World models went mainstream. When I lined up current world-model research against Semantic Spacetime, I kept finding the same four relations under different names. Reinforcement learning has state containment, transitions, similarity for generalisation, and state features. LLM agent architectures rebuild them. Neuroscience has described them for decades. The transitions, the LEADS TO edges, are always the part doing the predictive work. A world model is, at its core, a causal model you can roll forward.

The causal tooling matured, but in separate rooms. This one took me the longest to see. There are at least three serious traditions of machine causality, and they barely talk to each other.

The statistical tradition, represented by libraries like DoWhy and EconML, estimates causal effects from data under explicit assumptions. It is rigorous and conservative. It asks you to draw the causal graph first, then tests what the data can support.

The commonsense tradition, represented by knowledge bases like ATOMIC-2020 and ASER, catalogues everyday if-then knowledge about events. If someone drops a glass, it breaks. If someone is insulted, they may feel angry. It is broad, shallow, and very useful as a prior.

The textual tradition, represented by work like UniCausal, extracts cause-and-effect claims from language: this sentence asserts that X led to Y.

Each tradition produces causal claims. The claims have completely different epistemic status. An effect estimated by DoWhy with a passing refutation test is not the same kind of thing as a commonsense rule from ATOMIC, which is not the same kind of thing as a sentence in a meeting note that says “the migration broke checkout”, which is not the same as an LLM’s confident guess.

Almost every agent memory system I’ve looked at flattens them into one edge type, or doesn’t store them at all.

That was the problem I spent the year on.

IV. What I underwrote

Here’s the honest part of an anniversary post.

Look at the book’s table of contents and count. Most of the pages go to space: location, proximity, layered graphs, containment, properties, frames, bigraphs. Time gets two conceptual chapters and a section on episodic memory. Near the end there’s a heading, Event and Causality Extension for Space Time, that is essentially a promissory note.

I had the thesis — why over where — and then spent most of the book on where.

The deeper mistake was about what the nodes are. The book, like most knowledge-graph work, treats entities as the primary citizens. People, projects, documents, places. Events happen to them.

Alfred North Whitehead would say that’s backwards, and after a summer with Process and Reality I agree with him. For Whitehead the world is not made of things that have events. It’s made of occasions — events — and what we call things are stable patterns running through them. A river is not an object that water flows through. It’s the flowing.

Apply that to agent memory and something clicks. Your user is not a node with properties. They’re a history. So is a project. So is the agent itself. And causality, crucially, is a relation between events, not between things. “Alice causes delays” is a slander. “Alice’s review on Tuesday led to the redesign on Wednesday” is a claim you can check.

If causality lives between events, and memory is supposed to answer why, then the event has to be the primary node.

That’s the step the book gestured at and didn’t take. The Causal Temporal Event Graph takes it.

V. The Causal Temporal Event Graph

A Causal Temporal Event Graph (CTEG) is a Semantic Spacetime graph in which events are the primary nodes, time is a first-class axis, and every causal edge is an attributed claim.

It isn’t a replacement for SST. It’s a channel inside it: the causal-temporal slice of the same space, using the same four relations, pointed at history rather than at structure.

Here’s how each relation behaves in a CTEG.

LEADS TO is the spine. Every edge between two events that says one led to the other. But — and this is the most important design decision in the whole model — LEADS TO carries a mode. Either it is temporal (A came before B, in the same context) or it is causal (A is claimed to have produced B). Both are legitimately LEADS TO in SST terms. Both are ordered successions. But they are never allowed to be confused.

That one attribute is the answer to Hume. Post hoc ergo propter hoc — after this, therefore because of this — is the oldest fallacy in causal reasoning. In most agent memory it isn’t even a reasoning error. It’s a schema error. The storage layer has no way to say “this came after that” without also implying “this came from that”. So the model can’t avoid the fallacy. It has nowhere to put the distinction.

In a CTEG, temporal succession is cheap and automatic. Every pair of events in the same episode gets ordered. Causal succession is expensive and explicit. It must carry evidence.

CONTAINS is episode structure and causal scope. A release contains its commits, its deploy, and its incident. A week contains its meetings. A conversation contains its turns. This is how episodic memory emerges without a separate episodic store: an episode is just a CONTAINS subtree over events.

CONTAINS also does something the book described but didn’t operationalise. It is the causal subspace. “Coffee after 4pm leads to bad sleep” is not stored as a global law. It’s stored inside the context — this person, this period, this life — where it was observed. Causal claims inherit their scope from what contains them.

NEAR is resemblance, demoted. In a CTEG, NEAR connects events that resemble each other: this incident looks like that one, this argument sounds like last year’s. It’s enormously useful for retrieval and analogy. It is never, under any circumstances, evidence of causation. The vector store is still there. It’s simply been given one job instead of four.

EXPRESSES PROPERTY describes events. Severity, cost, sentiment, duration, who was involved. The facts about an event that don’t connect it to anything else.

Time is an axis, not a field. Each event has an interval, not a timestamp: a start and an end. That matters, because real events overlap. A meeting happens during a sprint. An outage starts before the alert and ends after the fix. Interval relations — before, meets, overlaps, during, finishes — give you precise temporal structure, and they give you something else: a hard constraint on causation. A cause cannot start after its effect ends. You can’t prove causation from time, but you can disprove it. That’s the cheapest causal filter available, and most systems don’t use it.

VI. Causality as a claim with an author

Now return to the problem from section III: causal claims from very different sources, with very different reliability, all collapsed into one edge.

In a CTEG, every causal LEADS TO edge carries a causal basis: where the claim came from and what kind of evidence stands behind it. After a year of iteration, I use roughly six.

Observed. Someone intervened and watched. The feature flag was turned off and the error rate dropped. This is the strongest basis a personal or team memory usually gets. It’s a real experiment, even if it’s an informal one.

Estimated. A statistical method, the DoWhy/EconML tradition, estimated an effect from data under stated assumptions. The edge should keep a reference to those assumptions, because the claim is only as good as them.

Commonsense. A general prior from something like ATOMIC-2020 or ASER. “Missing a meeting tends to lead to missed information.” Useful for filling gaps. Weak on its own. It should never override local evidence.

Extracted. A claim found in text. A postmortem says the migration broke checkout. The CTEG records that the document asserts it, with a link to the source. It doesn’t record it as fact.

Declared. A person said so. “I always get headaches after those calls.” Declared causality is subjective, and that’s fine. For personal memory it’s often the most important kind, because it tells you what the person believes, which drives what they do.

Inferred. An LLM proposed it. This is the Humean basis: habit, pattern, plausibility. It’s the most abundant and the least trustworthy. It gets the lowest default confidence and it should be the first thing reviewed.

Each causal edge also carries a confidence, a polarity (does A promote B or inhibit it?), who asserted it, and when.

This changes what causality is inside the system. It’s no longer a property of the world that the model supposedly knows. It’s a claim with an author, a method, and a date. You can audit it, contest it, upgrade it when an experiment confirms it, and retire it when the evidence turns.

That’s how science treats causation. There’s no reason agent memory should be held to a lower standard.

VII. A worked example

Here’s a minimal CTEG schema in LadybugDB:

CREATE NODE TABLE Event(
  id STRING, kind STRING, label STRING,
  t_start TIMESTAMP, t_end TIMESTAMP,
  PRIMARY KEY(id)
);
CREATE NODE TABLE Episode(id STRING, label STRING, PRIMARY KEY(id));
CREATE NODE TABLE Property(id STRING, key STRING, value STRING, PRIMARY KEY(id));

CREATE REL TABLE LEADS_TO(
  FROM Event TO Event,
  mode STRING,          // 'temporal' | 'causal'
  basis STRING,         // observed | estimated | commonsense | extracted | declared | inferred
  polarity STRING,      // 'promotes' | 'inhibits'
  confidence DOUBLE,
  asserted_by STRING,
  asserted_at TIMESTAMP
);
CREATE REL TABLE CONTAINS(FROM Episode TO Event, FROM Episode TO Episode);
CREATE REL TABLE NEAR(FROM Event TO Event, score DOUBLE, basis STRING);
CREATE REL TABLE EXPRESSES(FROM Event TO Property);

Four relation tables, one per SST relation. The whole causal apparatus lives in LEADS_TO’s attributes.

Now go back to the question from the start: why did the launch slip?

MATCH (q:Episode {id: 'q3-launch'})-[:CONTAINS]->(slip:Event {kind: 'launch_slip'})
MATCH p = (cause:Event)-[:LEADS_TO*1..5 (r, _ |
            WHERE r.mode = 'causal' AND r.confidence >= 0.6)]->(slip)
RETURN p
ORDER BY length(p)
LIMIT 5;

This walks backward along causal edges only, and only the ones we trust. The reorg shows up in the answer only if someone actually linked it causally to the slip, with evidence. If it merely happened in the same month, it stays in the temporal layer, where it belongs.

The same structure answers a question vector memory can’t even phrase. Which of our causal beliefs are just confident guesses?

MATCH (a:Event)-[r:LEADS_TO]->(b:Event)
WHERE r.mode = 'causal' AND r.basis = 'inferred' AND r.confidence >= 0.8
RETURN a.label, b.label, r.asserted_by, r.asserted_at
ORDER BY r.confidence DESC;

That’s a review queue for the agent’s own habits. It’s Hume, operationalised: find the places where custom is posing as knowledge.

And one more, which I’ve found to be the most valuable query in practice. Where do our causal claims disagree?

MATCH (a:Event)-[r1:LEADS_TO]->(b:Event), (a)-[r2:LEADS_TO]->(b)
WHERE r1.mode = 'causal' AND r2.mode = 'causal'
  AND r1.polarity <> r2.polarity
RETURN a.label, b.label, r1.basis, r1.asserted_by, r2.basis, r2.asserted_by;

The postmortem says the new cache helped. The on-call engineer says it made things worse. In a flat memory, the most recent or most similar chunk wins, silently. In a CTEG, the disagreement is itself a first-class fact, and a very useful one. It’s usually exactly where the interesting conversation is.

VIII. What a CTEG doesn’t do

I want to be careful here, because causal AI attracts overclaiming.

A CTEG doesn’t compute causation. It won’t discover from raw events that the cache caused the latency. It won’t answer counterfactuals — “would the launch have slipped without the reorg?” — on its own.

What it does is hold the structure that those computations need, and keep their results honest.

Judea Pearl’s ladder of causation is a useful map here. The bottom rung is association: seeing that things go together. The second is intervention: what happens if I do this. The third is counterfactual: what would have happened otherwise.

Vector memory lives entirely on the first rung. It can’t even represent the second.

A CTEG stores results from all three rungs, each labelled with how it was obtained. It can hand a scoped causal subgraph, which as the book noted tends to be a DAG once you index by events, to a proper causal engine. It can receive the estimated effects back as edges with basis estimated. That’s the bridge I built Causal Canvas and the CausalJSON format for: a way to move causal models between the graph, the whiteboard, and the estimation library without losing their assumptions along the way.

The graph is the memory. The engines are the reasoning. The mistake the field keeps making is expecting the language model to be both.

IX. Why agents need this now

When this was a book about knowledge representation, causal memory was a nice-to-have. In 2026, with agents acting on our behalf, it’s starting to be structural.

Explanation. An agent that takes actions will be asked why. “Because it seemed relevant” isn’t an answer. A causal chain with bases is.

Learning from outcomes. An agent that can’t link its past actions to their consequences can’t improve. It can only accumulate. A CTEG turns every action into an event with downstream edges, so “what did my last three suggestions actually lead to?” becomes a query.

Credit and blame in multi-agent systems. When five agents contribute to a failure, somebody will ask which step caused it. Without event-level causality, the answer is a guess, and usually an unfair one.

Trust. And here’s where the year’s research comes full circle to the last chapters of the book. Promise Theory says an autonomous agent can’t be commanded. It can only promise, and others decide whether to rely on that promise. But what is a promise, in these terms? It’s a claim about a future LEADS TO: “if you give me this, it will lead to that.” Every kept or broken promise becomes a causal observation about the agent that made it. A CTEG is where that evidence accumulates. That’s how trust between agents becomes something you can compute, rather than something you configure.

That’s the next essay.

X. What the book is now

A year ago I’d have described Semantic Space Time for AI Agent Ready Graphs as a book about a knowledge representation framework.

Today I’d call it the grammar. It explains the four relations and why each exists. It explains why similarity isn’t meaning, why proximity depends on the observer, how containment builds worlds, how properties turn nodes into frames, and why LEADS TO, and the question “why”, sits at the centre. It ends with Promise Theory, which turns out to be where causal memory goes next.

Causal Temporal Event Graphs are what you build with that grammar once you take time and causality seriously. You can’t read the sentences if you skipped the alphabet.

If you’ve followed the Hume and Whitehead essays this summer and wondered where the formal backbone lives, the book is where it lives.

Originally published on Sovereign Agentic AI on Substack.