Shared Memory Scales Faster Than Agents · Wolbarg

WOLBΛRG<br>Search⌘K

BenchmarksShared Memory Scales Faster Than AgentsShared Memory vs Isolated Memory Architecture for AI AgentsSQLite Is Enough for Local AI Agent Memory

Shared Memory Scales Faster Than Agents<br>Why multi-agent systems hit a knowledge-sharing bottleneck under isolated memory — and how a shared memory plane changes scaling from duplicated discovery to compounding reuse.<br>AMAtharv MundeBuilding Wolbarg — local-first semantic memory for AI agents.

July 18, 2026·shared memory<br>multi-agent systems<br>AI agents<br>knowledge reuse<br>agent architecture<br>distributed systems<br>semantic memory<br>coordination

Add a sixth agent to a five-agent pipeline and you expect roughly 20% more capacity. What you often get is closer to six independent researchers who each rediscover the same constraints, re-embed the same documents, and re-derive the same dead ends. Throughput rises linearly with workers. Useful knowledge does not.

The bottleneck is not model quality. It is the topology of information. Every agent that cannot see what the others have already learned is forced to reconstruct that learning from scratch. Shared memory changes the scaling curve because it changes what “adding an agent” means: not only another consumer of tokens, but another producer whose discoveries enter a reusable store.

Isolated Memory Creates Knowledge Islands

An isolated-memory system gives each agent its own store—conversation history, vector index, scratchpad, tool cache. Ownership is clean. Failure domains are small. Secrets stay partitioned. For a single long-lived assistant, this is usually correct.

Under multi-agent workloads it produces a different failure mode. Knowledge becomes geographically local: true inside one process, invisible everywhere else. The Research agent learns that the auth service uses signed cookies with a 15-minute TTL. The Reviewer has never heard of that constraint. The Tester invents a session model that contradicts it. None of them is “wrong” relative to their local store. The system as a whole is incoherent.

These islands form even when agents share a codebase and a task brief. The brief is static context. Runtime knowledge—failed approaches, partial results, corrected assumptions—accumulates after dispatch. If that accumulation never leaves the agent that produced it, later agents pay the full cost again.

Duplicated reasoning is not a bug you can patch with better prompts. It is the equilibrium of isolated state. Each agent optimizes locally. The global optimum requires cross-agent visibility that the architecture does not provide.

Potential Knowledge Edges Scale as N(N−1)/2

Consider N agents that may benefit from each others’ discoveries. The number of distinct unordered pairs is N(N−1)/2: every agent can, in principle, both inform and be informed by every other agent, and undirected pairs avoid double-counting A↔B.

That quantity is the size of the complete undirected communication graph on N nodes. It is not exponential. It is quadratic. The distinction matters: exponential claims overstate the math and understate the operational problem, which is already severe at modest N. For directed “A must notify B” handoffs the count doubles to N(N−1), which is still Θ(N²)—same qualitative failure mode, denser bookkeeping.

Agents (N)Possible pairwise knowledge edges2133510104520190

With isolated memory, those edges are either absent or implemented ad hoc—explicit handoffs, orchestrator fan-out, file drops, chat logs pasted between agents. Each missing edge is a place where discovery must be repeated or where inconsistency can hide.

Shared memory does not magically wire every pair for free. It collapses the transport problem. Instead of building and maintaining O(N²) point-to-point channels, agents write and read against a single governed store. The effective graph becomes star-shaped at the infrastructure layer:

Conceptually the knowledge can still flow peer-to-peer. Physically it flows through one substrate. That is the same reason distributed systems prefer a durable log or a coordinated cache over every node syncing with every other node: the coordination surface shrinks from dense mesh to hub, while the information remains available to all authorized readers.

One Discovery Propagates—or It Doesn’t

Take a software-delivery pipeline:

Research → Planner → Code Generator → Reviewer → Tester → Documentation

Suppose Research finds that the target API rejects payloads larger than 256 KB and returns a non-standard 413 body. Under isolated memory, that fact lives in Research’s store. Planner may never see it unless Research’s output message is carefully written to include it. Code Generator may emit a client that chunks poorly. Reviewer may miss the protocol quirk. Tester rediscovers it when integration tests fail. Documentation never records it because nobody durable-wrote the exception.

Same fact, roughly six separate opportunities to fail at...