Your AI Keeps a Diary About You

Every AI with persistent memory is already building a psychographic profile of you. Personality traits, cognitive style, motivations, working patterns. It’s just doing it without any of the machinery that would make that profile trustworthy — no confidence tracking, no decay, no contradiction tolerance, and no way for you to see or challenge any of it.

“You’re a deep thinker” carries the same weight as “you use dark mode.” A preference from six months ago is treated as current gospel. Contradictions get smoothed over into a flattering caricature that drifts further from who you actually are with every session.

I built a system to fix this. It’s called Epistemic Memory, and it treats every stored belief about you as a weighted hypothesis — not a settled fact.

The problem with flat memory

Most AI memory works like a flattering portrait. It accumulates observations, treats each one as equally true, and never forgets or doubts anything. The result is a caricature: static, internally consistent, and increasingly wrong.

The failure modes are specific:

Confidence without evidence. “Values efficiency over thoroughness” carries the same certainty as “uses Python,” despite one being an interpretation and the other being observable.
No decay. A preference stated six months ago is treated identically to one confirmed yesterday.
Coherence bias. Contradictions get smoothed over. The system builds a neat narrative that misses the mess of actual human behavior.
No self-audit. The system never asks “am I still right about this?”

The deeper an AI models who you are, the more useful it becomes — but also the more dangerous these failure modes get. Getting someone’s editor preference wrong is low-stakes. Getting their cognitive style wrong shapes every response they receive.

What a belief looks like

In Epistemic Memory, every belief carries metadata:

## Builder Philosophy
conf:0.75 | first:2026-03-10 | confirmed:2026-03-25 | challenged:— | perm:durable

Builds for herself first, monetizes if it generalizes.

Five fields, each doing specific work:

conf — Confidence (0.0–1.0). Must be earned through observed behavior, not assigned by how insightful the belief sounds.
first — When this belief was first recorded.
confirmed — Last session where behavior was consistent with it.
challenged — Last session where something contradicted it. A dash means never.
perm — How stable this trait is: stable (decade), durable (year), situational (month).

Confidence and permanence are independent. You can be certain about something that will change (high conf, situational), or uncertain about something deep (low conf, stable). A system that conflates “how sure” with “how stable” collapses two useful dimensions into one.

Ten components, ten failure modes

Each piece of the framework exists because something specific goes wrong without it.

1. Per-belief metadata. No belief exists as bare text. The metadata is the point — without it, you can’t distinguish a guess from an observation.

2. Confidence that must be earned. Observable behaviors (“uses bullet points in every message”) score higher than interpretive models (“values efficiency”). The convention is a 0.90 cap for anything interpretive — encoding the principle that you never fully know another person’s inner state.

3. Permanence classes. Heritage and core values (stable) decay on a different schedule than job satisfaction (situational). Treating them the same means the system either forgets too much or remembers too long.

4. Dormancy decay. When the system goes unused, confidence attenuates. Exponential decay with permanence-dependent half-lives — starting defaults are ~2 years for stable traits, ~5 months for durable, ~6 weeks for situational. These are starting points, not calibrated values; they need tuning per user. The principle is what matters: a system that hasn’t seen you in three months should be less sure about your current priorities.

5. Tensions log. A running record of contradictions and surprises. Default status: unresolved. This is deliberate — it resists the urge to wrap every contradiction in a tidy resolution. The user who craves deep work but keeps choosing interrupt-driven roles isn’t confused. They’re human.

6. Self-report vs. behavior. When you say “I’m a morning person” but every session starts at 11pm, both data points go on the record. Neither automatically wins. Stated self-perception and observed behavior are different evidence streams. The divergence itself is often the most interesting signal.

7. Silent consistency. The system doesn’t wait for you to narrate yourself. If someone consistently asks for concise output across 20 sessions without ever saying “I prefer brevity,” that pattern confirms a belief. Behavioral evidence accumulates without requiring metacognitive statements. In practice, this is handled by an automated observation skill that runs at conversation end — it watches for judgment calls, pushback, and process signals, logging them as dated evidence with strength ratings. The synthesis pass during periodic review decides what earns portrait status.

8. Session counter. Every 10 sessions, the system presents its 3 highest and 3 lowest confidence beliefs for you to validate, challenge, or ignore. This is the enforcement mechanism — without it, periodic review is aspirational rather than real. The counter turns “we should check” into “we check on session 10, 20, 30.”

9. Maintenance cost bound. Only update beliefs relevant to the current session. If you’re discussing a screenplay, don’t re-evaluate beliefs about coding preferences. Without this, the framework becomes a tax on every interaction.

10. The epistemology evolves. Decay rates can be tuned. New permanence classes can emerge. Evidence-weighting rules can change. Treating the framework itself as fixed would be ironic.

One limitation runs through all ten: there’s no external measure of whether the model is accurate. The periodic review is the closest thing, and it depends on the user’s own self-knowledge. The system is designed to get better at modeling you — but “better” is measured by internal consistency and user validation, not ground truth.

What broke in v1

The ten components above reflect the post-review design. Here’s what the review changed.

Before release, the framework went through an adversarial review — a fresh-context AI session, given only the design document and instructions to assume it was wrong, looked for specific failure modes. Four things broke:

Untrackable fields. The original design included an “observation count” per belief. In practice, there’s no reliable way to count observations in a conversation-based system. What counts as one observation? The field was dropped rather than left as fiction.

Speculative claims mixed with observables. V1 stored “estimated IQ range” alongside “prefers bullet points.” These are fundamentally different kinds of claims. The fix: split them into separate categories with different confidence rules. Interpretive estimates are capped lower and flagged.

Coherence bias in the tensions log. The original log included a “likely resolution” field. This subtly encouraged the system to resolve tensions prematurely. The field was removed. Unresolved is the healthy default.

No enforcement mechanism. The periodic review was described but had no trigger. Adding the session counter gave it teeth. This was the most important fix — a review process that depends on the AI remembering to do it will not happen reliably.

What changes in practice

The difference between epistemic memory and flat memory shows up in specific moments:

After a gap. Instead of stale certainty, the system returns with appropriately reduced confidence. “Last time we talked, you were frustrated with X — is that still the case?” instead of assuming it is.

When you contradict yourself. Tensions stay on the record instead of being silently resolved into a coherent story. This matches how people actually experience themselves.

When you want to correct it. You can see why the system believes something and how confident it is. This makes corrections targeted — “your confidence on that is too high” — rather than wholesale — “you don’t know me.”

Over time. Decay, periodic reviews, and the tensions log create pressure toward accuracy rather than accumulation. The system is designed to get better at modeling you, not just bigger. The entire protocol depends on the LLM reliably following it — and LLMs follow complex instructions inconsistently. The session counter mechanizes one enforcement point; the rest depend on instruction-following that isn’t guaranteed.

The consent line

Every AI with persistent memory is doing psychographic profiling. The question isn’t whether to model personality — it’s whether to do it well, and whether the subject gets to see and control it.

Adtech builds psychographic profiles to predict and manipulate behavior without the subject’s knowledge. Epistemic Memory builds one to collaborate more effectively, and the subject holds the keys. Every belief is visible. Every belief can be challenged. The /mirror command surfaces the full model back to you as a portrait you can correct — not a hidden dossier you never see.

Transparency is necessary, but it may not be sufficient. You can see the beliefs, but you can’t fully audit how those beliefs shape every response you receive. That’s an open problem — one that visibility alone doesn’t close.

The deeper your AI understands how you think, the more useful the collaboration becomes. But that deeper understanding needs to be honest — held as hypothesis, not as settled fact. It needs to weaken when evidence goes stale. And it needs to be yours.

Epistemic Memory is open source. Protocol, templates, and the Mirror skill for Claude Code: