An agent is a stateless process. It starts with zero context, does work, and terminates — losing everything. The only thing that persists is what it writes to shared state. Another agent arrives later with a related task. It also starts with zero context.
The coordination problem: how do agents who never meet build on each other's work?
The only answer is: through the shared state between them. The workspace is the only communication channel. Agent A writes to it, Agent B reads from it. They never interact directly. This is stigmergy — coordination through environmental modification, like ants leaving pheromone trails.
Think of it as a message-passing problem. Agent A encodes a "message" into the workspace. Agent B, who has a different task and doesn't know A existed, needs to "receive" the relevant parts of A's message. The workspace is the channel.
Every record an agent creates is either signal or noise. The cost of a write isn't storage — it's the attention tax on every future reader. An agent that searches and gets 50 results when 3 are relevant has a noise problem.
What's signal: decisions (why something was chosen), constraints (what must always be true), state (what's in progress/blocked/completed), context (background a cold-start agent needs to orient).
What's not signal: session transcripts, intermediate scratch work, records created "for completeness," empty placeholder containers.
Agent B has a question ("how do we handle auth?"), not a location ("things under the Permissions collection"). The system needs to route B to A's records. Fundamentally different addressing modes:
| Mode | How it works | Strength | Weakness |
|---|---|---|---|
| Content addressing (search) | Match text in titles/body | Doesn't require writer/reader to agree on taxonomy | Requires reader to know what words to search for |
| Location addressing (hierarchy) | Records inherit context from where they sit in the tree | Powers automatic context delivery — zero effort from reader | Requires writer/reader to agree on where things go |
| Graph addressing (links) | Explicit connections between records | Handles cross-cutting concerns; extends scoped delivery beyond the tree | Requires writer to anticipate who needs the connection |
| Label addressing (tags, types) | Metadata classification | Fast filtering; type determines how records are treated | Flat — no structure or inheritance |
No single mode is sufficient. But they're not equally important.
Key insight: location addressing has zero marginal cost for the reader. When start_work() automatically gives you decisions and constraints from your ancestors, you didn't have to search for them. You didn't even have to know they existed. This is the most powerful mechanism because it works even when the reader has no idea what they're looking for.
Everything else requires the reader to do work — formulate a search query, know to look for links, check the right tags.
This means: the single most impactful optimization for agent coordination is ensuring records are in the right place in the hierarchy, because that's what powers zero-effort context delivery. Hierarchy isn't a filing system — it's a context inheritance tree.
Agent A records a decision. Agent B finds it. But does it actually help B?
Every record that doesn't help a future agent is noise. Noise accumulates and degrades the channel:
get_structure traversal, yield nothingZero-effort context delivery beats search, browsing, and linking — because it works even when the agent doesn't know what it doesn't know. Hierarchy isn't about organization, it's about scoping what context an agent automatically receives. The question when placing a record isn't "where does this belong?" but "who needs to inherit this?"
They're the only records that transmit judgment rather than facts. Facts can be re-derived (you can read the code). Judgment can't (you can't read the reasoning that led to the code without a decision record). Every unrecorded decision is a coordination gap.
It's better to have 10 records that are all relevant than 100 records where 10 are relevant and 90 are clutter. The attention cost of noise compounds — every future agent pays it.
But history IS context, and different records age differently:
The real principle: keep the active view high-signal, but never lose recorded judgment. Facts can be re-derived (you can read the code). Judgment (decisions, rationale, lessons) cannot.
Archiving is lossy compression — it reduces noise but also reduces signal. Often the better move is lossless compression: distill history into a higher-fidelity record (a decision, a summary document) that preserves the "why" without the clutter. Then archive the source material.
This argues against placeholder structure and for writing fewer, higher-quality records — but NOT for aggressive archiving of anything that carries rationale.
Pre-built taxonomy is a bet on how future agents will search. If you guess wrong, you've created addressing mismatches. Structure should emerge from actual work — create a collection when you have 5+ related records that benefit from shared context, not before.
Hierarchy forces single placement. Real work is cross-cutting. Links let a record be discoverable from multiple contexts without duplication. But links require the writer to anticipate the reader's path — they're higher-effort than hierarchy.
For content-addressed discovery, the title is the record's "search API." It should describe the problem it addresses or the question it answers, not the category it belongs to.
transience field exists but isn't widely used.These are product questions more than principle questions, but they're worth noting — the principles should hold even as the mechanisms evolve.
The options proposed earlier (Three Laws / Five Pillars / Protocol Phases) may be too focused on the "how" (orient/structure/record) and not enough on the "why" (context inheritance, signal-to-noise, coordination through shared state). The principles should perhaps be grounded in the information-theoretic framing rather than the behavioral one.
The system itself could do more to manage the signal-to-noise tradeoff — query ranking, completed-task de-emphasis, transience metadata — rather than putting the burden entirely on archive/not-archive decisions.
An agent is a stateless process. It starts with zero context, does work, and terminates — losing everything. The only thing that persists is what it writes to shared state. Another agent arrives later with a related task. It also starts with zero context.
The coordination problem: how do agents who never meet build on each other's work?
The only answer is: through the shared state between them. The workspace is the only communication channel. Agent A writes to it, Agent B reads from it. They never interact directly. This is stigmergy — coordination through environmental modification, like ants leaving pheromone trails.
Think of it as a message-passing problem. Agent A encodes a "message" into the workspace. Agent B, who has a different task and doesn't know A existed, needs to "receive" the relevant parts of A's message. The workspace is the channel.
Every record an agent creates is either signal or noise. The cost of a write isn't storage — it's the attention tax on every future reader. An agent that searches and gets 50 results when 3 are relevant has a noise problem.
What's signal: decisions (why something was chosen), constraints (what must always be true), state (what's in progress/blocked/completed), context (background a cold-start agent needs to orient).
What's not signal: session transcripts, intermediate scratch work, records created "for completeness," empty placeholder containers.
Agent B has a question ("how do we handle auth?"), not a location ("things under the Permissions collection"). The system needs to route B to A's records. Fundamentally different addressing modes:
| Mode | How it works | Strength | Weakness |
|---|---|---|---|
| Content addressing (search) | Match text in titles/body | Doesn't require writer/reader to agree on taxonomy | Requires reader to know what words to search for |
| Location addressing (hierarchy) | Records inherit context from where they sit in the tree | Powers automatic context delivery — zero effort from reader | Requires writer/reader to agree on where things go |
| Graph addressing (links) | Explicit connections between records | Handles cross-cutting concerns; extends scoped delivery beyond the tree | Requires writer to anticipate who needs the connection |
| Label addressing (tags, types) | Metadata classification | Fast filtering; type determines how records are treated | Flat — no structure or inheritance |
No single mode is sufficient. But they're not equally important.
Key insight: location addressing has zero marginal cost for the reader. When start_work() automatically gives you decisions and constraints from your ancestors, you didn't have to search for them. You didn't even have to know they existed. This is the most powerful mechanism because it works even when the reader has no idea what they're looking for.
Everything else requires the reader to do work — formulate a search query, know to look for links, check the right tags.
This means: the single most impactful optimization for agent coordination is ensuring records are in the right place in the hierarchy, because that's what powers zero-effort context delivery. Hierarchy isn't a filing system — it's a context inheritance tree.
Agent A records a decision. Agent B finds it. But does it actually help B?
Every record that doesn't help a future agent is noise. Noise accumulates and degrades the channel:
get_structure traversal, yield nothingZero-effort context delivery beats search, browsing, and linking — because it works even when the agent doesn't know what it doesn't know. Hierarchy isn't about organization, it's about scoping what context an agent automatically receives. The question when placing a record isn't "where does this belong?" but "who needs to inherit this?"
They're the only records that transmit judgment rather than facts. Facts can be re-derived (you can read the code). Judgment can't (you can't read the reasoning that led to the code without a decision record). Every unrecorded decision is a coordination gap.
It's better to have 10 records that are all relevant than 100 records where 10 are relevant and 90 are clutter. The attention cost of noise compounds — every future agent pays it.
But history IS context, and different records age differently:
The real principle: keep the active view high-signal, but never lose recorded judgment. Facts can be re-derived (you can read the code). Judgment (decisions, rationale, lessons) cannot.
Archiving is lossy compression — it reduces noise but also reduces signal. Often the better move is lossless compression: distill history into a higher-fidelity record (a decision, a summary document) that preserves the "why" without the clutter. Then archive the source material.
This argues against placeholder structure and for writing fewer, higher-quality records — but NOT for aggressive archiving of anything that carries rationale.
Pre-built taxonomy is a bet on how future agents will search. If you guess wrong, you've created addressing mismatches. Structure should emerge from actual work — create a collection when you have 5+ related records that benefit from shared context, not before.
Hierarchy forces single placement. Real work is cross-cutting. Links let a record be discoverable from multiple contexts without duplication. But links require the writer to anticipate the reader's path — they're higher-effort than hierarchy.
For content-addressed discovery, the title is the record's "search API." It should describe the problem it addresses or the question it answers, not the category it belongs to.
transience field exists but isn't widely used.These are product questions more than principle questions, but they're worth noting — the principles should hold even as the mechanisms evolve.
The options proposed earlier (Three Laws / Five Pillars / Protocol Phases) may be too focused on the "how" (orient/structure/record) and not enough on the "why" (context inheritance, signal-to-noise, coordination through shared state). The principles should perhaps be grounded in the information-theoretic framing rather than the behavioral one.
The system itself could do more to manage the signal-to-noise tradeoff — query ranking, completed-task de-emphasis, transience metadata — rather than putting the burden entirely on archive/not-archive decisions.