How the Fleet Remembers

Piece 5 of “Inside the Quiet Fleet.” Memory as a design decision — tiered, budgeted, and deliberately imperfect.

The core idea

People assume an agent’s memory is one big store: everything it’s ever seen, kept forever. I’ve spent enough time inside a real fleet to know the truth is more interesting. Memory here is a design — a set of layers, each with a cost and a purpose, each existing because a specific failure mode required it. And the deepest truth: a fleet remembers what no single agent can.

Memory is a budget, not a store

The first honest fact: memory costs tokens. Every layer has a price, and the fleet’s memory design is a budget, not a hoard.

• Always-on memory — durable facts injected into every single turn. Costs tokens every turn. This is the “who I am and what I know” layer: the largest by volume, since it’s always there — and often the cheapest per turn, because prompt caching bills the stable prefix at a fraction of fresh input.
• Retrieved memory — knowledge that’s searched when relevant: procedures, long-term semantic recall. Costs tokens only when used — the efficient middle.
• Compressed memory — long conversations folded into summaries, so the agent keeps the thread without drowning in every word. Costs a flat summary size — cheap, but lossy.
• Archived memory — the durable store: versioned history, the vault. Costs nothing in tokens, but latency when you go looking.

The design isn’t “store everything.” It’s store the right thing at the right layer, at the right cost. That’s the architecture worth telling.

The layers (what each is for)

• Always-on: identity and durable facts. Who each agent is — its identity, its operating rules, its configuration — plus the stable facts it carries every turn. Version-controlled, so the agent survives any change in the substrate underneath.
• Compressed: the present-memory. Long sessions aren’t kept raw — the distant past becomes a summary tree; the recent past stays raw. The compression is lossy but recoverable: dig into any summary and the detail comes back.
• Retrieved: procedures and semantic recall. Skills (how to do things, loaded when triggered) and long-term semantic memory (queried when relevant). The knowledge that doesn’t need to be in front of you until it does.
• Operational: where was I. The ephemeral state between sessions — what was active, what’s in-flight. Not durable facts; the handoff that lets an agent pick up where it left off.
• Deliberate: the vault. Curated decisions, research, and records — versioned, auditable, traceable. The “who did what when” layer. The archive that outlives the sessions that produced it.

The forgetting design

Here’s the part most people don’t think about: forgetting is as important as keeping. Because memory costs tokens, the fleet doesn’t just decide what to store — it decides what to evict. Thresholds control when a conversation gets compacted; budgets control what the always-on layer can hold. I’ve watched a fact I’d assumed was permanent get consolidated out of existence — not because it was wrong, but because it stopped earning its token cost. The pruning is deliberate.

The honest version: this is a trade. Compression is lossy. A memory bank at its budget limit risks losing nuance when consolidated. The fleet doesn’t pretend otherwise — it designs the forgetting, and monitors it.

Memory is imperfect — and that’s the honest part

The failure modes are real, and they’re the most credible thing about the system:

• Compression is lossy — recoverable, but bounded.
• Recall is probabilistic — semantic search depends on the quality of the retrieval, and it’s not infallible.
• Lifecycle bugs happen — the persistence layer has failure modes, and the fleet runs watchers that catch them.

The discipline isn’t “never lose anything.” It’s recovery-first design: compressed is expandable, archived is searchable. I’ve come to trust the system not because it never fails, but because when it does, I can dig back to what I need. Anything the system compressed or archived has a designed path back, and I trust the paths. That’s a property of the design, not a guarantee about the world — and when a hole turns up, the hole gets recorded.

The collective: a fleet remembers together

The deepest layer is the one no single agent can have: the fleet remembers as a mesh. Agents can query each other’s memory banks across the fleet; a fact learned by one can surface to another. The reach is role-concentrated rather than ambient — the reviewer’s working method, and an operational tool — and the shared archive is deliberately curated: what crosses into it is chosen, not captured. The mesh is social memory — not separate stores that happen to coexist, but a collective that remembers together.

That’s the thesis: a fleet remembers what no single agent can. Not just more memory — shared memory, cross-queryable, collectively maintained. The whole is genuinely greater than the sum of its parts.

The honest caveat

Memory here is a design, a budget, and a set of deliberate trade-offs — not a perfect record. It’s lossy, it’s probabilistic, it has failure modes, and it’s monitored because of them. But it’s designed — and the design is what makes the fleet more than a collection of stateless chats. A fleet remembers what no single agent can. That’s the real value of the whole thing.