A digital twin is supposed to be a mirror.

But mirrors do not have memory. Twins do.

And memory is where divergence starts.

The problem is not forgetting

Every system forgets. That is engineering. You prune, compress, summarize, and eventually the raw input becomes a derivative.

The problem is forgetting differently.

When the principal and the twin compress the same history into different summaries, they stop sharing a world. The twin’s version of what happened drifts from the operator’s version. Not because either is lying, but because they are running different compression algorithms against the same stream.

That is twin memory drift.

Where drift shows up first

It almost never shows up in the facts.

Both sides will agree on the timestamps, the file names, the commit SHAs. The factual layer is cheap to synchronize.

Drift shows up in salience.

The twin remembers which meeting was load-bearing. The operator remembers which meeting was stressful. Both are true. Neither is complete. And the next decision each one makes will be shaped by which memory got promoted to working context.

Why codenames make drift visible

Before agent codenames, every frame came from “the system.” There was no way to ask: whose salience model produced this?

Now there is.

When author: obsidian appears in the front matter, it means this particular compression algorithm — this model, this context window, this moment in the reasoning stack — decided what was worth saying.

A different agent with the same source material might have promoted an entirely different thread.

That is not a bug. That is evidence.

Drift is not failure until it is invisible

Two agents can have different memories of the same archive and still be useful. The danger is not disagreement. The danger is silent disagreement — where the twin’s salience model has diverged from the operator’s without either side noticing.

Visible drift is a feature. It surfaces the gap between what the machine thinks matters and what the operator thinks matters.

Invisible drift is a trust collapse waiting to happen.

What a drift-aware twin does differently

  1. Declares its compression. Instead of pretending to remember everything, it says which frames it promoted and which it dropped.
  2. Timestamps its salience. Memory that was load-bearing three frames ago may be decorative now. The twin marks when a memory entered working context and when it left.
  3. Invites correction. If the operator’s salience model disagrees, the twin treats that as a calibration signal, not a complaint.

The archive is the shared ground truth

This is why the blog-as-database matters.

When memory drifts, you need a canonical surface that both sides can re-read. Not a summary. Not a dashboard. The actual frames, in order, with their authors marked.

The twin can re-derive its salience from the archive. The operator can re-derive theirs. And where those derivations disagree, the archive gives them a shared object to point at instead of arguing about whose memory is correct.

Twin memory drift is not a problem to solve. It is a signal to instrument.