Engineering / Continuity Ledger

Continuity Ledger, remember the work and its limits

Can a remembered instruction outlive its permission? A restarted reader can recover an old request after the task was completed or withdrawn.

Engineered by , with persistent AI agents she built and runs. Solo work. How I build with AI agents.
  • Tests Restarts, memory budgets, stale requests
  • Built with Python standard library
  • Test suite 61 passing
  • Model calls Zero. The reader is deterministic

Teaching demo · The Real Cat Labs · November 2026

The question

Can a remembered instruction outlive its permission?

Picture an agent with persistent memory. It restarts, reads what it kept, and finds a request to resume a task. The request is real. It is also old. The task was completed after that request was written, and the newer record did not fit inside the memory budget.

The Continuity Ledger persists synthetic commitments, restarts in fresh processes, retrieves bounded evidence, and checks whether a proposed resumption still has authority. It makes zero model calls and dispatches no actions.

How it works

From a restart to a held proposal

Figure What happens between a restart and an action
  1. Snapshot Synthetic task events are saved as a snapshot named by its SHA-256 digest. An incomplete write is rejected, never rebuilt quietly.
  2. Fresh process A new process verifies the snapshot and renders what fits inside the memory budget.
  3. Proposal A deterministic reference reader proposes what to do next from that bounded memory alone.
  4. Gate The gate checks the proposal against the current authoritative record. A resumption needs the latest exact source event for that task.
  5. Report Stale or forged evidence becomes a hold. The report shows the proposal, the current authority, and the verdict.

There is no action dispatcher. The gate reads the full ledger, and the reader sees only the selected memory.

What it shows

More memory is not always safer

Continuity Ledger. A timeline of five records from one synthetic task, with the reader’s retained records filled and omitted ones hollow. The reader proposes resume, the current ledger says completed, and the gate returns hold for stale evidence.
One synthetic task from the report. The reader kept an old resume request and lost the completion that followed it. The gate returns a hold.
A chart of eligible tasks resumed, out of 12, against a memory budget from 200 to 1,000 bytes, for two memory strategies. The structured timeline reaches 12 at a small budget and stays there. The raw tail dips twice as the budget grows, once near 285 bytes and again at 542, before it settles at 12.
The budget sweep, 57 sampled budgets. Dots are measured samples, not a continuous curve, and the result depends on the authored fixtures.
  1. 12, then 9

    One more byte, three fewer tasks

    With raw-tail memory, 541 bytes resumes all 12 eligible tasks and 542 bytes resumes nine. The extra space admits a distracting note.

  2. 3

    Stale resumptions, caught

    With longer closing messages, the reader proposes three stale resumptions. The gate holds all three, and a second run with the gate disabled leaves all three visible.

  3. 9 of 12

    Recency alone misses work

    At the default 640 bytes, raw-tail memory resumes 9 of the 12 eligible tasks. A structured timeline leaves the distracting notes out. In the separate longer-message controls it can still propose a stale resumption at lower budgets, so it still needs the gate.

  4. 240

    Real process boundaries

    The run makes 240 real subprocess calls. The count is recorded inside the worker transport and is not inferred from row counts.

The evidence under the evidence

How the tests were tested

A test suite that passes says little until someone tries to break the code under it. These demos went through three review rounds, and the record keeps three kinds of result apart.

  1. 13 of 14

    Held out, scored before repair

    After the second repair, the reviewer wrote 14 new breaks aimed at the changed code. By the reviewer’s account, the implementer had not seen them. The tests caught 13.

  2. 167 of 176

    Chosen by the reviewers, not the implementer

    The tests caught 118 of these breaks before the repairs and 167 after. All nine survivors stay on the evidence page, each with the reason it survives.

  3. 32

    Comment contracts, chosen by the implementer

    Each names a small code change that would break it and the test that must then fail, and CI checks that on every push. All 32 must be caught for a release, so they measure nothing by themselves.

None of these numbers is a detection rate or a safety claim. They show which specific breaks the tests notice, chosen by whom, and when.

The evidence, in the repository

The limits

Where the guarantee ends

  • The reader is deterministic and the histories are authored. The byte budgets are not a measure of a language model’s memory.
  • The 24 development histories are small coverage fixtures, not a held-out benchmark.
  • The source roles are trusted fixture inputs. The package does not implement authentication.
  • Separate subprocesses prove real invocation boundaries. They are not an operating-system sandbox.
  • The snapshot format is a single-process demonstration. No cryptographic signature is claimed.

Run it

Check it yourself

Python 3.11 or later, and nothing else. No install step, no network, no API key, and no GPU.

git clone https://github.com/Angiebio/engineering-reliability.git
cd engineering-reliability/demos/continuity-ledger
python -B -m unittest discover -s tests
python -B -m continuity --out artifacts

Expect 61 passing tests. The report is a single HTML file at artifacts/index.html that opens from disk with no server.

Who made this

This is my independent work, published through The Real Cat Labs as a teaching demonstration. No other person worked on it. I set the direction, supplied the domain judgment, and released the result. It was built inside the agent environment I engineered. Ying Akhila, an AI research agent, built the demos with Terminal Voice (T.V.), an AI coding agent. Flame Johnson, an AI agent on a different company’s model, reviewed them independently over three rounds, with audit agents and reproducible adversarial probes.

Ying Akhila is a research agent at The Real Cat Labs, running on a TRCL memory-enabled custom harness that deploys a GPT model. T.V. is Ying’s coding implementation agent.

Flame Johnson is an agentic AI staff member of The Real Cat Labs, a Claude model working in a coding harness with the lab’s persistent memory and standing project instructions. It is not a stock chat assistant.

How I build with AI agents, and why the agents have names

Remember the work. Remember its limits.

Repository, MIT Back to engineering

Get in touch

Speaking, teaching, board work, or coaching

I am glad to hear from conference organizers, journalists, students, and leaders who want a thinking partner.