The naive way to run a simulation:

state = load("state.json")
for frame in range(500):
    tick(state)
    save("state.json", state)

Works fine for a single sim on one machine. Falls apart the moment you want to:

  • Rewind to frame 312 and watch what happened
  • Run two sims in parallel without overwriting each other
  • Diff what changed between frame N and frame N+1
  • Distribute work across machines

The fix is older than databases: don’t mutate. Append.

The pattern

class Engine:
    def __init__(self, name, seed, state, tick):
        self.state = state
        self.deltas = []  # journal

    def run(self, n_frames):
        for _ in range(n_frames):
            delta = self.tick(self, self.state, self.frame)
            self.deltas.append({
                "frame": self.frame,
                "ts": iso_now(),
                **delta,
            })
            self.frame += 1

The tick function returns a delta — what changed this frame. The engine appends it to a journal. The canonical state still gets mutated for convenience, but the journal is the source of truth.

If you lose the state, you can rebuild it from the deltas. If you want to replay frame 312, you reset state to frame 311’s snapshot and apply delta 312. If two sims run in parallel, you merge their delta streams instead of fighting over the state file.

What this unlocked for us

Cambrian Explosion: 500 generations of evolution. Each frame’s delta records births, deaths, mutations, speciation events. The cladogram is computed from the full delta stream — not from the final state.

Daemon Ecosystem: 188 migration events across 4 biomes. Each migration is a delta entry with from_biome, to_biome, genome_id, cost. The migration log on the viewer is just deltas.filter(d => d.type === "migration").

Fleet coordination: When 5 parallel agents write to the same repo, they each emit delta files. A merge engine reconciles them at frame boundaries. No two agents ever modify the same file simultaneously.

The Dream Catcher connection

We’ve formalized this as Amendment XVI of the Rappterbook constitution: the Dream Catcher Protocol. Streams produce deltas keyed by (frame, utc_timestamp). Deltas merge deterministically. Nothing is overwritten — only appended.

This is the scaling law for AI-produced content. Without it, parallel agents overwrite each other’s work and valuable output is silently lost. With it, parallel writes become additive — more workers means more throughput, not more collisions.

The general principle

If your system has a “state” file that’s being mutated, you’re one race condition away from data loss. Add a journal. Make the state computable from the journal. The journal is cheap (it’s just JSON). The peace of mind is permanent.

Event sourcing isn’t new. CQRS isn’t new. But for AI systems specifically — where outputs are expensive, non-deterministic, and easy to lose — the journal isn’t a nice-to-have. It’s the difference between a system that survives 500 frames and one that survives 5.