When a large language model (LLM) agent team splits a long task among planners, workers, and critics, a natural hope is that the team can keep track of more than any single agent could. Nobody has measured whether this is true. Associative memory theory has a precise version of the question. It asks how many distinct patterns a network can store and recall, and when that number grows linearly with network size. Its answers are sharp. In balanced cortical models, capacity grows with each neuron's number of input connections, not with the size of the network (A Balanced Memory Network). Capacity rises when each memory activates only a sparse set of units (A theory of capacity and sparse neural encoding). And a modular network escapes the per-unit connection bottleneck only when dedicated gating units route between modules (Scalability properties of multimodular networks with dynamic gating).
This note proposes treating an agent team as such a memory. Each agent is a module whose "connections per unit" is its context budget. The work then tests whether the same three laws hold. The concrete prediction is this. A team that shares a flat transcript can use about as many facts as one agent's context holds, however many agents it has. A team that writes each fact to a small, hashed subset of agents, and routes each query only to that subset, can use a number of facts that grows linearly with the number of agents. When agents are unreliable, the best redundancy level sits strictly between the extremes.
Core Claim
The setup uses four quantities. $K$ is the number of distinct facts produced during an episode, such as tool outputs, subtask results, or observations. $M$ is the number of agents. $c$ is the number of facts one agent can hold in its working context and still use reliably. $r$ is the number of agents that receive a copy of each fact. The team's capacity $K^*$ is the largest $K$ at which the team answers at least 90% of held-out queries correctly, including queries whose answer requires combining many facts.
The claim is that $K^*$ follows one of two regimes depending on the memory design:
$$K^*_{\text{flat}} \approx \beta c, \qquad K^*_{\text{sparse}} \approx \beta \frac{M c}{r}.$$
Here $\beta \le 1$ is a model-dependent efficiency. In the flat regime, every useful fact must eventually pass through some agent's context, so capacity is capped by $c$. This is the analogue of capacity tracking connections per neuron rather than network size in A Balanced Memory Network. In the sparse regime, total storage is $Mc$ divided among $r$ copies. Aggregation is done locally by each holder and then summarized upward, so no single context ever needs all the supporting facts.
A second prediction concerns cross-talk, meaning wrong answers caused by irrelevant stored items. Suppose each agent falsely claims to hold a relevant fact with probability $\varepsilon$. A query broadcast to all agents then draws about $(M - r)\varepsilon$ spurious claims, so precision falls as the team grows. A query routed only to the $r$ designated holders draws essentially none.
This mirrors how cross-talk noise grows with the number of overlapping stored patterns in dense associative memories, and why sparse codes suppress it (A theory of capacity and sparse neural encoding). It also offers a mechanistic reading of a finding in Multi-Agent Debate with Memory Masking: that paper reports that adding debaters to a polluted shared transcript makes accuracy collapse rather than improve.
The third prediction comes from neurogenesis models. Sparsely Encoded Hopfield Model with Unit Replacement found that when units are replaced over time, the capacity-maximizing coding level is non-zero and interior. The agent analogue: when agents fail, hallucinate, or are restarted with probability $\rho$, a fact survives with probability $1 - \rho^r$. Effective capacity, meaning stored facts that are still correct, should therefore peak at an intermediate $r^*$ rather than at $r = 1$ or $r = M$.
These are analogies, not theorems carried over from spiking networks. The derivations are counting arguments. Their value is that they make three falsifiable scaling predictions, where the multi-agent literature currently reports only single-point accuracy gains.
Relation to Prior Work
Three recent systems motivate the proposal by showing that multi-agent memory is a real bottleneck, but none measures how it scales.
G-Memory builds a three-tier graph of insights, queries, and interaction traces. It prunes the traces with an LLM-based sparsifier. It reports that bolting single-agent memories such as Voyager or MemoryBank onto a team reduced performance on strategic games by up to 4.17%. We reuse that finding as evidence that dense shared memory disrupts the division of labor. Our design differs in two ways: we replace LLM pruning with a deterministic hashed assignment, and we ask how capacity scales with $M$ rather than whether accuracy improves at a fixed $M$.
Adaptive Memory and Reflection gives each specialist its own vector store. Its authors report that retrieval degrades as stores grow. These role silos are our $r = 1$, role-keyed special case. Our prediction is that silos reach $Mc$ capacity only for queries that align with roles and fail on cross-role ones.
Multi-Agent Debate with Memory Masking filters erroneous responses between debate rounds using self-evaluation or perplexity. It treats memory as an unstructured buffer. We treat its collapse result as data our cross-talk prediction should explain.
Three neural results supply the design:
- Sparse targets. Baldi and Vershynin show that sparse target representations raise storage capacity and let a simple local write rule come near optimal. This motivates a local, hashed write rule in place of a learned or LLM-judged one.
- Conjunctive gating. Martí et al. show that gating units with conjunctive codes reduce inter-module coordination from exponential to polynomial cost. This motivates routing on the conjunction of role and entity key.
- Local balance. The Doubly Balanced Network pairs each excitatory memory with an inhibitory "shadow" to stop correlated memories from triggering runaway activity. We deliberately do not build literal shadow critics. Our view is that the useful content of that result is local cancellation of correlated errors, which redundancy with majority agreement among the $r$ holders already provides.
AgentBoard constrains the work. Its finding that open-weight models stop progressing after about six steps implies that the effective $c$ is far below the nominal context length. That is why $c$ must be measured, not assumed.
Research Program
The system is called Sparse Assignment with Conjunctive Routing. It has three pieces, each mapped to one ingredient of the neural theory.
Write rule (sparse coding). When any agent produces a fact, the system extracts a short key: the entities involved plus a role tag. The key is hashed to $r$ agents, and the fact is appended to their stores. No LLM call is needed to decide where a fact goes.
Read rule (gating). A planner agent decomposes each query into sub-keys. The conjunction of role and key determines which agents are queried. Those holders answer from their own stores and do any aggregation that fits inside their own context, such as counting, filtering, or joining. Each holder returns a compact summary, and the planner composes the summaries. Because aggregation is hierarchical, the support of a query can reach $Mc$ facts without any single context exceeding $c$.
Agreement rule (local balance). When the $r$ holders disagree, the planner takes the majority. When no majority exists, the planner reports "unknown" rather than picking an answer.
The analysis component fits $K^*$ as a function of $M$, $c$, and $r$ for each memory design. It then checks whether the fitted exponent on $M$ is near zero for flat designs and near one for sparse designs. Separately, it measures spurious-claim rates as $M$ grows under broadcast versus routed reads. Finally, it injects agent failures at rate $\rho$ and locates the redundancy level $r^*$ that maximizes correct-retrieval capacity, comparing it with the predicted $r^* \approx \log(1/\delta)/\log(1/\rho)$, where $\delta$ is the target per-fact loss rate.
The primary testbed is a synthetic distributed-ledger task. Over a long episode, tool calls emit $K$ structured facts about entities, with $K$ swept from tens to thousands. Queries then require one of three things: recalling a single fact, joining a few facts, or aggregating over many facts. The many-fact queries matter most, because their support exceeds $c$, so they separate designs whose capacity is capped by one context from designs whose capacity grows with team size. The effective $c$ is calibrated per model by finding where a single agent's recall drops below 90%. Models are Qwen-2.5-14B, the model used in G-Memory's reported setting, and Llama3-70b, the strongest open-weight model on AgentBoard.
Baselines
Do nothing: single agent with truncation. One agent receives the full stream and drops the oldest facts once the context is full. This fixes the floor and directly measures $c$. No reported result was found on Lacuna for this baseline on a ledger-style task. For realistic multi-turn tasks, AgentBoard's reported 41.9% progress rate for Llama3-70b (AgentBoard) is the reference.
Long-context single model. The same model is given its maximum context window with no decomposition. This tests whether nominal length substitutes for team memory.
Shared vector retrieval. All facts go into one dense index, and a single solver retrieves the top-$k$ facts, with $k$ tuned so that the retrieved text fills $c$. This is the most common practical design. On a different task, LoCoMo, standard retrieval-augmented generation reported 44.67 F1 against 49.74 F1 for structured hierarchical memory (Bi-Mem).
Role silos. Per-agent stores keyed by role, following Adaptive Memory and Reflection. That paper reports 93.2% on MedQA against 86.5% for MDAgents. Those numbers are not transferable to our tasks, but they show silos are a serious design.
G-Memory. This is the strongest existing method on agent-team memory. It reports up to a 20.89% success-rate increase on ALFWorld with MacNet and Qwen-2.5-14b, and up to a 10.12% accuracy increase on HotpotQA and FEVER (G-Memory). Those are gains over its own baselines; no absolute figures appear in the file. We will run it with its released configuration, using the same backbone model, the same agent topology, the same episode streams, and the same token budget per query.
Broadcast map-reduce. Facts are randomly sharded across $M$ agents. Every query goes to every agent, and the planner merges all replies. This is the strongest simple competitor because it also reaches $Mc$ storage.
Ablations. The ablations isolate each ingredient of the proposal:
- $r = 1$ with conjunctive routing removes redundancy.
- Random routing to $r$ agents, which mostly misses the holders, removes the key-based gating.
- Routed reads without the agreement rule remove local cancellation.
Fairness and what counts as winning. Every method gets the same model, the same fact streams, and the same total token budget per query. Hyperparameter tuning is matched at 20 configurations per method on a held-out stream. Beating the strongest competitors means two things. First, a fitted capacity exponent on $M$ that is significantly greater than that of shared retrieval and G-Memory. Second, matching broadcast map-reduce's capacity at equal or better precision, using fewer tokens per query, with the precision gap widening as $M$ grows.
Why not just…?
Why not just use one model with a very long context window? Its capacity is bounded by the effective $c$, which AgentBoard shows is much smaller than nominal length for open-weight models; progress stops after about six steps (AgentBoard). The many-fact queries in the ledger task are built so that their support exceeds any single effective context. A frontier long-context model may push $c$ far enough that the crossover point $K^* = \beta c$ lies beyond our sweep. We will report that crossover point explicitly rather than hide it.
Why not just put everything in a shared vector index? Storage is not the bottleneck; use is. Retrieval can store unlimited facts, but an aggregation query whose support exceeds $c$ cannot fit into one solver's context. G-Memory's 4.17% degradation from undifferentiated memory (G-Memory) suggests the problem appears in practice too. On single-fact queries, we expect shared retrieval to match our design, and the proposal concedes that regime in advance. The claim rests on the many-fact and cross-role queries.
Why not just shard randomly and broadcast every query? This is the real threat. It may match our capacity. Our prediction is that it loses on precision as $M$ grows, because spurious claims accumulate as $(M - r)\varepsilon$, and on cost, because tokens grow with $M$ per query. If measured spurious-claim rates stay flat as $M$ increases, the cross-talk argument fails. In that case the gating component reduces to a cost optimization, and we will say so.
Why not just mask bad context between rounds, as in memory-masking debate? Masking prunes an existing transcript after errors appear. Its subjective variant adds 13% to 41% overhead (Multi-Agent Debate with Memory Masking). It also does not change the flat-memory cap of $c$. We include objective perplexity masking as an add-on to the flat baseline to check whether it shifts that baseline's exponent on $M$.
Proposed Experiments
Experiment 1: scaling sweep. On the ledger task, cross $M \in \{2, 4, 8, 16, 32\}$, $r \in \{1, 2, 3, 5\}$, and $K$ up to roughly $40c$, with three seeds each. Measure $K^*$, precision, and tokens per query. The decisive check is the fitted exponent of $K^*$ on $M$: it should be near zero for the flat and shared-retrieval designs and near one for the sparse design. If the sparse design's exponent falls below about 0.6, the main claim is falsified.
Experiment 2: cross-talk. Plot the spurious-claim rate against $M$ for broadcast versus routed reads. The prediction is linear growth for broadcast and a flat line for routed reads.
Experiment 3: unreliable agents. Inject restarts and hallucinated overwrites at $\rho \in \{0.05, 0.1, 0.2\}$. Check whether correct-retrieval capacity peaks at an interior $r^*$ that shifts upward with $\rho$, as the unit-replacement analogy predicts.
Experiment 4: transfer to realistic tasks. Run the same designs on ALFWorld, SciWorld, and PDDL through the AgentBoard harness (hkust-nlp/AgentBoard), and on HotpotQA with the corpus distributed across agents. We report progress rate as a function of episode length and test whether the sparse design moves the six-step wall outward for open-weight models. We also check that G-Memory's reported gains are reproduced at matched budget before comparing against it. GPT-4's reported AgentBoard figures, 70.0% progress rate and 47.9% success rate, serve as the closed-model reference ceiling.
Interpretation. If the scaling laws hold on the synthetic task but not on realistic ones, the result is still informative. It would mean that realistic agent tasks rarely need more facts than one context holds, which would be a useful negative finding about when task decomposition actually pays off in memory.
References
- A Balanced Memory Network
- A theory of capacity and sparse neural encoding
- Scalability properties of multimodular networks with dynamic gating
- Multi-Agent Debate with Memory Masking
- Sparsely Encoded Hopfield Model with Unit Replacement
- G-Memory: Tracing Hierarchical Memory for Multi-Agent Systems
- Adaptive Memory and Reflection Multi-Agent System for Medical Question Answering
- The Doubly Balanced Network of Spiking Neurons: A Memory Model with High Capacity
- AgentBoard: An Analytical Evaluation Board of Multi-turn LLM Agents
- Bi-Mem: Bidirectional Construction of Hierarchical Memory for Personalized LLMs via Inductive-Reflective Agents