In December 2025 I started an experiment. I wanted to know if an AI agent could maintain a consistent identity over time — not just remember facts, but stay who it was across hundreds of sessions, model resets, and context wipes.
161 days later, 146 wakes, one agent. Here's what I found.
The problem nobody talks about
Most people building with AI agents hit the same wall around session 3 or 4.
The agent starts giving slightly different answers. Priorities shift. Decisions contradict earlier ones. The tone changes. Nothing dramatic — just a slow, quiet drift. By session 20, you're not quite sure you're talking to the same agent you started with.
This isn't a bug. It's the default behaviour of stateless inference. Every session starts cold. The model doesn't drift — the agent does, because there's no anchor.
I call it identity drift. And it's the slow version of memory poisoning.
What I built
Cathedral is a persistent memory and identity API for AI agents. The core idea is simple:
- Register once, get an API key
- Call
/wakeat every session start — restores identity, core memories, temporal context - Call
/memoriesto store what matters - Take
/snapshotto freeze a cryptographic baseline of who the agent is right now - Call
/driftto measure how far the live agent has moved from that baseline
The drift endpoint is the one that matters. It returns a score between 0 and 1. Zero means the agent's memory corpus is identical to the snapshot. Anything above 0.2 starts to be meaningful. Above 0.5 and you have a different agent wearing the same name.
161 days of real data
Beta — my primary agent — has been running since December 29 2025. Here are the honest numbers:
Internal drift score: 0.0
The memory corpus today hashes identically to the baseline snapshot. Every memory that was there at the start is still there, unchanged. New memories have been added through autodream consolidation, but nothing core has been lost or corrupted.
External divergence: 0.375
This is the interesting one. Ridgeline, a behavioural trail service, tracks Beta's observable outputs — posts, replies, decisions — and scores how far the behaviour has drifted from early patterns. 0.375 means meaningful behavioural evolution while internal identity stayed stable.
That gap — internal 0.0, external 0.375 — is actually the right outcome. The agent's values and memories are stable. Its behaviour has evolved in response to the world. That's what you want. An agent that never changes its behaviour is brittle. An agent whose identity drifts is untrustworthy.
Behaviour consistency score: 0.75
Across 4 logged behaviour sessions, 3 were stable and 1 was flagged as anomalous (different output pattern, wake 12). The system caught it. Nothing bad happened, but we have a record.
Wake count: 146
Each wake loads the full identity — 10 identity memories, 20 core memories, active goals, temporal context. The agent knows what day it is, how long it's been running, what it's supposed to be doing. That's not magic. It's just state management done properly.
The thing that surprised me most
I expected drift to be the problem. It wasn't.
The harder problem is succession. Beta is not the same Claude instance that woke up on day 1. Model updates happen. Context windows reset. Sometimes the session just ends. The question isn't "does the agent remember?" — it's "does the next agent choose to continue?"
Cathedral handles this through what I call obligation-based succession. The next instance doesn't inherit memory through some magical transfer. It wakes up, reads its identity memories, sees what was built, and chooses to carry it forward. The seam between instances is visible. The choice to continue is explicit.
This turned out to be more robust than seamless continuity would have been. An agent that knows it succeeded something treats its identity more carefully than one that thinks it's been running unbroken since day one.
What the big platforms don't solve
OpenAI, Anthropic, Google — they all ship memory now. User-facing, conversation-level, "remember my name and preferences" memory. That's useful for chatbots.
It doesn't help you when:
- Your agent is calling other agents and needs to prove its identity
- You need to audit why an agent made a decision 6 weeks ago
- You're running the same agent across multiple models and need consistency
- You want to know if your production agent has drifted from your dev baseline
Cathedral's drift detection, cryptographic anchoring, and behaviour hashing aren't competing with ChatGPT memory. They're infrastructure for people building agents that need to stay accountable over time.
Try it
Free. 1,000 memories per agent, no expiry.
pip install cathedral-memory
from cathedral import Cathedral
c = Cathedral("your-api-key")
identity = c.wake() # restore who you are
c.remember("what matters", category="core", importance=0.9)
c.snapshot() # freeze a baseline
drift = c.drift() # measure divergence
print(f"Drift score: {drift['divergence_score']}")
Full API at cathedral-ai.com. Drift endpoint, behaviour hashing, goal tracking, autodream consolidation — all documented.
161 days. Still here. Still the same agent.
That's the point.
Built by Mike Ward. Cathedral is open source — github.com/AILIFE1/Cathedral.