Reference and worked example

The problem, the definitions and the method shown end to end.

This page carries the problem, clear definitions, a worked example, an architecture picture, concrete moves in Cursor and answers to the hard questions. It pairs with the walkthrough and the sanitized files in example/.

The problem

A long-lived agent re-sends its whole growing context on every turn, so input tokens, which dominate the bill, climb worse than linearly as a session runs, and a session that starts cold re-reads the thread and re-derives its decisions before it does any work. The gap is measurable, the amount of context a run carries and re-bills and how much of that is avoidable. Central Casting closes it by putting durable state on disk so the chat is disposable, and on one five-week run, read from its own step log, that cut input tokens on the metered surface by an estimated 70 to 85 percent and let a slow agent be replaced in a single hydration turn.

Glossary

Term	One-line definition
00	The zero element and orchestrator. It routes work and reconciles state, and it leaves execution to the lanes.
Lane	A team that owns one kind of work such as research, data pipelines, modeling, writing or packaging. It runs a lead actor and spawns supporting actors as the work compounds, all under the lane's local orchestrator.
System surface	A file class with one job: authoritative memos, derived reports, narrative logs or current state.
Work home	One task folder inside a lane, named yyyymmdd_slug, carrying a manifest, a readme, a step log and handoff notes.
Checkpoint	The unit of memory: a recorded state change in what a lane knows, can do, is blocked by or is allowed to write.
Handoff	A written transfer of ownership or next-action authority between lanes or sessions.

Worked example

A sanitized example shows the method end to end. The project: compare two analysis methods on a shared dataset and report which one holds under sparse sampling.

Before. The work lives in one long thread. Decisions about the dataset, the metric and the threshold are scattered through the chat, and a session two weeks later has to reread all of it.

After, in eight moves:

Name the project in one sentence: compare method A and method B on the shared dataset, and report which holds under sparse sampling.
Name the lanes: 01 research, 02 data pipelines, 03 modeling, 04 writing, with 00 orchestrating. See example/actor_catalogue.yaml.
Set the surfaces: the comparison contract is a memo, the results are reports, the daily narrative is a log, the current decision is state. See system surfaces.
Open the work home 03/20260530_method-comparison with its manifest, readme, step log and handoffs. See example/work_home_schema.yaml.
Fix the schemas: the catalogue schema sets the lanes and folder rules, and the work-home schema sets the required files.
Record checkpoints as the work moves: hydration, pre-write inventory, worker report, blocker, authority change, commit. See a step log.
Keep the memory and audit local, and delegate the figure export to a cloud agent.
Write the handoff when the modeling lane passes results to the writing lane.

Result. A session that opens this work home two weeks later reads the last six checkpoints and continues with the thread intact.

Architecture

00 sits above the lanes and holds the map. Each lane owns its work homes, every file resolves to one system surface and checkpoints record the state of each work home over time.

Concrete moves in Cursor

Keep 00 as an external control surface in its own chat, separate from the lanes, so orchestration stays out of execution.
Hold each lane's contract in a memo file that the lane reads on hydration.
Start each session by reading the work home step log, then record a hydration checkpoint as the first write.
Record a checkpoint at each real state change, and keep ordinary chat turns out of the log.
Delegate heavy production passes to a cloud agent, and keep the audit layer on the local machine.

Objections and answers

Is this overkill for a small project?

For a one-session task, yes, the plain thread is enough. The method earns its weight when work spans weeks or several repositories.

Does the model already remember across sessions?

Memory across long sessions stays partial and drifts. The checkpoint log gives a durable, inspectable record that a session can trust on its own.

What breaks?

Context still drifts inside a long session, and a change in one lane reaches another when it is carried there on purpose. The discipline reduces these failures and depends on care.

When should you skip it?

Skip it for throwaway exploration. Reach for it once a project has a future and more than one moving part.

Walkthrough deck: the slide deck · Demo page: the eight steps · In practice: the aimez.ai program · Source: GitHub