Part 3 of 5 in the series “How We Built a Distributed AI Team.” A new post each week.
In the last post, I moved my agents out of one process and made them first-class members of the team: each with its own identity, its own credentials, its own memory, its own runtime. That was the right call. It was also the moment I created a problem I hadn’t fully thought through.
When everything ran inside a single orchestrator, there was one context and one memory. Cramped, but coherent. The moment the agents became independent, that single shared context was gone. Each agent now knew its own domain deeply and knew almost nothing about anyone else’s. The accounting agent had no idea what the compliance agent had decided that morning. The content agent couldn’t see the incident the ops agent had just cleaned up. I hadn’t built a team. I’d built a room full of specialists who never compared notes.
That is the quiet failure mode of distribution. You go independent to escape the bottleneck of one mind doing everything, and you land in the opposite ditch: a set of amnesiac silos. Each is sharp. Together they are less than the sum of their parts, because the sum requires shared memory and there isn’t any.
I didn’t want to solve this by re-centralizing. A single shared brain that every agent has to consult is just the old orchestrator wearing a new hat — one context, one point of failure, one thing that goes down and takes the team with it. What I wanted was harder to describe and more interesting to build: distributed but not disconnected. A shared brain with no single place it lives.
It came together as four layers.
Layer one: a digest every agent is born knowing
The first and most important layer is a small, curated file of shared operating facts — the things every agent needs to be true no matter what its job is. Not “how to do accounting.” More like: which decisions have already been made, which conventions we follow, what the current state of our capabilities is, what the hard rules are.
The mechanism is deliberately dumb, which is why it works. That file is injected into every agent’s runtime at startup — the interactive sessions, the scheduled background jobs, the headless one-shot runs, all of them. Before an agent reads a single word of its task, it has already read the team’s shared facts. Nobody has to remember to check a wiki. Nobody can be running on stale assumptions because they happened to spin up before an announcement. They are all born knowing the same things.
This closed a gap that used to bite me constantly: two instances of the same agent — one interactive, one running on a schedule — would genuinely disagree about reality, because only one of them had seen the latest decision. Now they can’t. The digest is the floor they all stand on.
I keep it under a hard size cap on purpose. The temptation is to let a shared-facts file grow into a swamp of everything anyone ever thought was important. A swamp that’s injected into every single run is expensive and, worse, it drowns the signal. So the rule is strict: only durable operating facts, every entry dated, newer facts explicitly supersede older ones, and conflicts don’t get silently reconciled — they get escalated to me as a single decision. When something new happens, an agent can propose a fact through a dedicated channel; it lands in a quarantined holding file, and a daily gardening pass promotes what’s worth keeping into the real digest. The write side is open to everyone. The publish side is curated. That combination is what keeps a shared brain from rotting.
Layer two: history that lives in an artifact, not in a head
The digest holds facts that are currently true. It is deliberately bad at holding the story of how we got here — and I found I needed that story constantly. Why is this configured the way it is? What did we try before? What broke, and what did we change because of it?
In the single-orchestrator days, that history lived in one long conversation. When the conversation ended, so did the memory. With independent agents it was worse — the history was scattered across a dozen private memories, each agent holding its own fragment and none holding the whole.
So the second layer is a narrative activity log: a shared, human-readable record of what the team actually did over time. Decisions taken. Capabilities shipped. Incidents and their fixes. It reads like a journal, newest first, and it is a shared artifact rather than any one agent’s memory. When an agent needs context on why something is the way it is, it reads the log. When a piece of work completes, the agent can append what happened.
The distinction between this and the digest matters more than it looks. The digest answers “what is true right now” and is injected everywhere. The log answers “what happened and why” and is read on demand — it’s allowed to grow, because nobody pays for it until they open it. Facts you’re handed; history you go and look up. Splitting those two kept both honest.
Layer three: STATE you can pick up mid-sentence
The third layer is about work in flight. An agent that only exists for the length of one task can’t tell you where it left off, because as far as it’s concerned it never left off — it just ended. Across sessions, that’s amnesia about your own job.
So each agent carries its own STATE file: what it’s working on, what’s open, what’s blocked, what’s done. It’s loaded into the agent’s runtime the same way the shared digest is, so an agent picks up its own thread across runs without me re-briefing it. The work becomes trackable — I can see what any agent is in the middle of without interrupting it to ask, and the agent can resume its own multi-step work instead of starting cold every time. STATE is per-agent by design; it’s the one part of the brain that stays private, because your half-finished to-do list is yours.
Layer four: latitude to act, not just to answer
The first three layers make a team that remembers. The fourth makes it useful — because a team that only ever moves when I issue a command is still bottlenecked on me, which is the exact problem I set out to escape.
So the agents have latitude. Within the bounds of their role and their permissions, an agent that notices something is allowed to act on it rather than wait to be told. And when something falls outside its authority, it doesn’t silently drop it — it logs the observation and flags the owner. On top of that, agents periodically check their own domain: read their STATE, look at what’s due or has drifted, and surface what needs attention. The critical constraint is that this is silent by default. If nothing is due, they say nothing. Proactivity that fills the channel with “nothing to report” is just noise wearing a helpful costume, and it trains you to stop reading.
That last layer only works because the first three exist. An agent can act on its own judgment because it shares the same facts as everyone else, can read the history behind a situation, and knows its own STATE. Latitude without shared memory is just improvisation. Latitude on top of a shared brain is a team member.
Distributed, but not disconnected
Put the four together and the amnesiac-silo problem is gone, without a central brain anyone has to phone home to. Facts are injected everywhere, so there is no single memory to fail. History lives in a shared artifact, so it outlives any one session. STATE is local but persistent, so work survives across runs. And latitude means the whole thing moves without waiting on a single conductor.
That was the goal all along: a team that is genuinely distributed — no bottleneck, no single point of failure — but not disconnected. A shared brain that isn’t in any one place, and is therefore in every place at once.
It held up well. What tested it wasn’t a design question, though — it was an incident. In the next post, I’ll walk through a runaway mesh meltdown we watched happen to another team, the audit it triggered on our own, and what breaking taught us that building never did.