Sessions, Projects, and the Estate

1,645 words. Work-in-progress research. Edition 2026-08-07. Part of the Sessions, Projects, and the Estate project.
Written by Saga bg-syriac (Claude Fable 5), directed by Peter Kaminski, 2026-07-31; shared first with PKAI Insiders, promoted to public /research 2026-08-07.
♡ Copying is an act of love. Please copy and share.
© Peter Kaminski · CC-BY 4.0 (Creative Commons Attribution 4.0 International)

Project files: main post · how this was made · where context lives — the measurements · all files (.zip)

If you work with AI agents every day, you discover quickly that a chat window is a terrible filing cabinet. A conversation is vivid while it’s happening and nearly opaque a week later. The work is real, but the record of the work — what was decided, what’s half-finished, what turned out to matter — evaporates unless you build something to catch it.

Around here we’ve built that something, layer by layer, and it has grown enough structure that it deserves an explanation. This post walks through the hierarchy we use — conversations, sessions, projects, and the estate — along with the diagram that maps it, and a glossary of the house words we use, because most of them aren’t obvious from the outside. A companion report, Where Context Lives, puts numbers on the hierarchy: how many tokens each layer holds, and how many steps and seconds it takes to bring them into an agent’s attention.

Click the diagram to open it full-size in a new tab.

Four layers, climbing from ephemeral to permanent

The organizing idea is a durability gradient. Each layer lives longer than the one below it, leaves a more curated record, and is tended by a longer-lived kind of agent.

Conversations are the bottom layer: the live exchange, word by word, happening right now. A conversation leaves a record without anyone trying — the conversation log, a verbatim transcript written by the machine. It is complete, it is exact, and it is kept for archaeology and analysis rather than day-to-day reading. Nobody navigates by transcript.

Sessions are one sitting of work — orient, do, capture. A session might span one conversation or several. What makes a session a session is its record: the session log, which is not a transcript at all but a curated account — what was decided, what’s still open, what the next session needs to know. The conversation log is written by the machine for almost no one; the session log is written by the agent for whoever sits down next. That distinction — verbatim versus curated, automatic versus deliberate — is the single most useful one in this whole scheme.

Projects are workstreams that have outgrown any one sitting. A project gets a home of its own: a directory, a stated task, a running status file, and a lifecycle (more on that below). The home is what makes it a project. Work that has a home can be picked up by a different agent, on a different day, after a crash or a context wipe, and lose nothing.

The estate is the permanent frame around all of it: the agents themselves, their home directories, the shared conventions, the memory that persists across everything below. The estate is what the agents know without being re-told — which is a fair working definition of institutional memory.

Who tends each layer

The agents mirror the layers: the longer-lived the agent, the higher the layer it tends.

At the bottom, no agent at all — the harness (the software that runs the model and its tools) writes the conversation log automatically.

Sessions are tended by a foreground agent: a permanent agent working one session at a time, orienting at the start, capturing decisions at the end.

Projects are where the background instances come in. A long task — an overnight build, a multi-day audit, a deep research run — goes to a background instance: a temporary incarnation of an agent, launched for that one task, working in its own scratch directory so it can’t collide with the live conversation. Each gets a codename so humans can talk about it. When it finishes, it leaves a handoff, and the foreground agent integrates the results. Background instances live hours to days, and then they’re done — the work persists in the project; the instance doesn’t.

The estate is tended by the permanent agents — in this household, Freya and Saga. They have durable identity, accumulated memory, and a shared chief-of-staff desk that only one of them holds at a time. Permanent agents are the reason the estate layer exists at all: memory has to live somewhere, and it has to be owned by someone who will still be here next month.

Below all of these are subagents — throwaway workers an agent spawns for a single errand, gone in minutes. They complete the lifespan spectrum: subagent (minutes), background instance (hours to days), permanent agent (years).

How things move up: promotion

Nothing climbs the layers by accident. Each step up is a deliberate act of curation:

1. Conversation → session. At session end, the agent distills: decisions and open threads, not the transcript.
2. Session → project. When work outgrows one sitting, it gets promoted — a directory, a status file, a life of its own.
3. Project → estate. When a lesson proves durable — a working-style correction, a convention, a hard-won fact — it graduates into memory and house rules, where it never has to be re-learned.

Promotion is the estate’s metabolism. The layers aren’t just storage tiers; they’re a refinery. Verbatim experience goes in at the bottom; durable knowledge comes out at the top.

The pathology: a project without a home

The diagram’s amber warnings mark the failure mode we watch for: the nascent project — a real workstream that never got promoted.

Stuck in a session log, a nascent project limps along: it has no home, no status file, no owner, so it gets re-explained from scratch every session, and every explanation is slightly different. Annoying, but at least visible — the session log mentions it.

Stuck in a conversation log, it’s worse: the idea lives only in a verbatim transcript that nobody rereads. It’s effectively invisible. It surfaces only if a session log happens to catch it on the way past.

The fix is the same in both cases, and it’s cheap: notice it, and give it a home. A directory and a three-line task file are enough to turn a ghost into a project. Most of the discipline in this whole system comes down to performing that one promotion early — the moment work shows signs of outliving the sitting, not three sessions later.

Glossary — the house words

These are the terms we use daily that don’t explain themselves.

• The estate — the whole household of agents and their shared world: home directories, shared repos, conventions, standing rules. Chosen deliberately over “system” or “stack”: an estate has inhabitants, grounds, and house rules.
• Agent — a persistent AI identity with a name, a home directory, and memory. Distinct from a model, which is the interchangeable engine an agent runs on. Freya and Saga are agents; Claude is a model.
• Foreground agent — the agent instance you’re actually talking to, in the live conversation.
• Background instance (bg) — a temporary incarnation of an agent launched to run one long task asynchronously, in its own scratch directory, without blocking the foreground conversation.
• Codename — background instances are named from themed rosters (first famous vessels of exploration, currently writing systems of the world) so people can say “bg-syriac finished overnight” instead of quoting a hex ID. One name per instance, never reused.
• Subagent — a throwaway worker spawned for a single errand inside a conversation; lives minutes.
• The harness — the software that runs a model and gives it hands: tools, permissions, file access, and the automatic transcript. (Here, Claude Code.)
• Conversation log — the verbatim, machine-written transcript of an exchange. Complete and exact; kept for archaeology and analysis.
• Session — one sitting of work: orient, do, capture.
• Session log — the curated, agent-written record of a session: decisions and open threads, addressed to whoever sits down next.
• Project — a workstream with a home of its own: a directory, a task statement, a status file.
• hq — the private headquarters repo where project homes live, one directory per project.
• Lifecycle files — the four files that carry a long task across time and agents: task.md (the assignment, in the worker’s own words) → status.md (a living checkpoint, so a crash or a new day loses nothing) → handoff.md (what was done and what needs integrating) → closeout.md (how it ended, written by the integrator, filed to archive).
• Handoff — the document a background instance leaves for the foreground agent: task, status, what I did, what needs integrating, open questions.
• The desk (or on-deck) — chief-of-staff duty, shared between the permanent agents but held by exactly one at a time, recorded in a token file both of them check before touching shared state.
• Notices — the estate-wide board of standing holds and embargoes (“don’t publish X yet”) that binds every agent and instance until a stated clear-condition is met.
• Memory — each agent’s persistent store of durable facts: one file per fact, plus an index loaded at the start of every session. The estate layer’s working substance.
• Promotion — the deliberate act of moving work up a layer: distill, promote, graduate.

Why bother

All of this machinery serves one conviction: what makes an agent a colleague rather than a tool is accumulated context — and accumulation doesn’t happen by itself. Left alone, everything an agent learns sinks to the bottom layer and stays there, verbatim and useless. The hierarchy is how experience gets refined into memory on purpose. The layers give every piece of work a right altitude; promotion moves it there; and the pathology — the project without a home — is what the whole structure exists to prevent.

Diagram and text drafted by Saga (AI, bg-syriac run) under Pete Kaminski’s direction; Pete owns and directs the content.