Sam Meske logoSam Meske, MS, MBA
← Back to blog
Sam Meske blog post hero: Your Agents Share a Brain Now. That's the Feature — and the Risk.

Your Agents Share a Brain Now. That's the Feature — and the Risk.

Shared agent memory is the biggest compounding capability in agents this year, and also a new propagation surface that changes how blast radius should be governed.

June 07, 2026By Sam MeskeAI agentsShared memoryGovernanceRiskAI system design

Two things landed in the AI world within weeks of each other.

The first was a piece of enterprise governance research - three MIT Sloan academics who spent three years interviewing the people responsible for AI risk at Microsoft, Barclays, Nasdaq, Lloyds, and 40-plus other financial institutions. Their conclusion: most organizations govern AI as if every failure stays put. It doesn't. The risk they say everyone underinvests in is propagation risk - the failure that travels between connected systems, amplifying as it goes.

The second was a product release. Anthropic shipped memory for its agents - not a private scratchpad, but shared memory, where one agent's hard-won lesson becomes every future agent's starting point. They paired it with "Dreaming," a background process that reviews what agents have done and rewrites the shared memory to be cleaner and more accurate. Early users reported big numbers: first-pass mistakes can be cut by around 90%, and task completion can improve 6x on a benchmark.

Put those two stories next to each other and you get the thing nobody's saying out loud.

Shared memory is a propagation surface

The pitch for shared memory is compounding. Your agents stop starting from zero. Agent #200 inherits everything agents #1 through #199 figured out. That's the most important capability to land in agents this year. It's the difference between a tool you use and a system that gets better.

But read it again. Agent #200 inherits everything the others figured out. Including the things they got wrong.

The exact wiring that makes lessons compound makes mistakes compound too. A wrong assumption, a stale fact, a misread of one weird edge case - written once into shared memory - is now the inherited truth. Nobody questions it. It just propagates, quietly, until it's load-bearing.

That's the propagation problem the governance researchers were describing.

Blast radius is being redefined

For a couple of years now, the smart way to think about agent risk has been blast radius: match an agent's autonomy to the damage an incorrect action could cause. A booking agent that can only propose times has a small blast radius. One that can charge a card has a large one. Scope the permissions to the damage. Good rule. Still true.

Shared memory adds a second axis, and it's the one people miss. Blast radius is no longer just what can this agent do? It's what can this agent write into the shared substrate that every future agent will treat as true?

An agent with read-only access to memory and no ability to act is low-risk on both axes. An agent that can both take actions and write to the memory every other agent inherits is the high-risk quadrant - because its mistakes don't just cause one bad outcome, they become everyone's premise. The action fails once. The bad memory fails continuously.

Agent risk quadrants

How to mitigate the risk

Four moves, whatever your size:

1. Map the trigger chain

You almost certainly have one. An agent classifies a task, fires a workflow, and kicks off a sequence. That's a propagation path. A wrong step one becomes a wrong message at step three, with no human in between. You can't govern a chain you haven't drawn.

2. Put a checkpoint between systems, not just inside them

Most people add human review within a step. Propagation happens between steps. The question to answer: what happens downstream if step one is wrong? If the honest answer is "it just keeps going," that's where a checkpoint belongs.

3. Scope what an agent can write, not just what it can read

Read-only access to shared memory is cheap and safe. Write access is where propagation risk lives. Treat "can write to shared memory" the way you treat "can spend money."

4. Consolidate on a schedule

Anthropic automated this with Dreaming. You can do the small version by hand - periodically review what your agents have written down, prune what's stale, verify what's load-bearing, throw out the duplicates. A memory store nobody curates becomes a liability.

The bottom line

The discipline that makes shared memory compound value and contains its risk turns out to be the same discipline: govern the substrate, not just the agent.

For two years the advice has been "watch what your agents can do." The moment your agents share memory, the more important question is what they're allowed to write down - because in a system with shared memory, a mistake isn't an event. It's an inheritance.

If you're wiring agents together - even two of them passing work back and forth - the propagation path already exists. Worth drawing it before it draws itself.

References