A thirteen-agent team should not give every agent access to every conversation or document. Give each model call a small working context, keep selected collaboration state in a governed memory layer, and retrieve authoritative documents from permission-controlled sources when needed. The right way to pass that context—through shared storage, coordinator-built messages, separate agent stores, or a hybrid—depends on who should see it, who owns the canonical state, and how much consistency and operational control the team needs.
What “memory” means in a multi-agent system
Memory is not one undifferentiated transcript. A useful design separates three jobs:
As an Amazon Associate I earn from qualifying purchases.
- Short-term memory holds recent session context, such as an active task and its unresolved questions.
- Long-term memory retains selected information across sessions, such as a durable preference or a reusable task specification.
- Working memory is the context assembled for a particular model call. It may contain relevant short-term or long-term memory, retrieved documents, and the current instruction. It is the information the model actually receives; storing something does not make it visible to the model automatically.
Microsoft’s Multi-agent Reference Architecture describes the distinction succinctly: “Working memory is the only thing the model ever sees.” A memory layer therefore needs a retrieval and assembly policy as well as storage.
Memory is also different from a knowledge base. Memory records selected user, session, and collaboration context that might otherwise be lost. Business policies, product documentation, and other authoritative content belong in controlled repositories or indexes. Retrieve those sources when needed so authorization and freshness can be checked at query time, rather than copying changing documents into memory indefinitely.
#1 Best Overall
Choose how agents receive context
There is no universally best context-passing pattern. The main choices differ in where canonical state lives and which component controls disclosure. Microsoft’s reference architecture discusses shared, distributed, and hybrid short-term-memory patterns; Microsoft ISE separately compares ways to pass context between agents.
| Pattern | How it works | Advantages | Costs and risks | Best fit |
|---|---|---|---|---|
| Shared storage or context ID | The coordinator sends an identifier; authorized agents read or write the same store. | Small messages, a common source of truth, and convenient access to long histories or centralized queries. | Agents depend on shared infrastructure and credentials; the exposure surface and number of storage calls can grow. | Trusted internal agents already have storage access, histories are long, or centralized querying matters. |
| Coordinator-embedded context | The coordinator retrieves and selects context, then includes it in each agent’s message, optionally summarizing it. | Agents can remain stateless; the coordinator can control what each sees; message-based tests are straightforward. | Requests grow and context is transferred repeatedly; summaries can omit details. | Agents are independently deployed, cross organizational boundaries, or need tightly controlled disclosure. |
| Per-agent state | Each agent maintains its own store, with state associated through a session or context identifier. | Agent autonomy, isolation, and independent retention choices. | State may diverge; synchronization, migration, and audit aggregation take more work. | Agents need independent long-running context and do not need a common view of all state. |
| Hybrid or subgroup memory | An explicitly chosen group of agents shares a memory area while other agents remain outside it. | Limits visibility to collaborators and can partition task load or retention. | Group membership and memory lifecycle need deliberate management. | Some agents collaborate on a task while others should not see that task’s state. |
As Microsoft ISE puts it, passing context between agents is “a design decision that ripples through your entire architecture.” Compare the patterns against access boundaries, canonical-state ownership, consistency and auditability, payload size, storage or network latency, scalability, autonomy, and ongoing operating effort. Those trade-offs matter more than choosing a pattern because it is fashionable.
Design a thirteen-agent context flow
Thirteen agents do not need thirteen copies of the same memory. Treat the number of agents as a coordination problem: define what each role needs, which state is shared, and where permission checks happen. The following is an illustrative design, not a claim about a deployed team.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
- Choose a coordinator. It receives the task, assigns work, and decides which context each specialist needs. Where the coordinator embeds context in messages, it becomes a useful disclosure-policy point, but also takes on responsibility for selection and can increase payload size.
- Define scopes before adding agents. Label each memory item by its intended scope, such as user, session, agent, subgroup, or tenant. State who owns it, which roles can read or write it, when it expires, and how it is deleted.
- Assign state ownership. Decide which component is authoritative for each shared decision or result. If more than one store can be updated, specify how updates are coordinated and how the complete state will be reconciled and audited.
- Route the minimum useful context. Send each specialist the task, relevant decisions, necessary constraints, and the specific data it is permitted to use. A specialist that only needs a schema or current task status should not receive another agent’s full session history.
- Validate handoffs and reconcile results. Use typed payloads, check outputs before they enter shared state, and have the coordinator resolve conflicting agent results rather than silently treating each as canonical.
- Record durable outcomes selectively. Persist reusable decisions or task context according to a retention policy; do not make raw transcripts the default long-term record.
For each agent, a compact handoff can identify the task, the context scope, the relevant state or reference, and the expected output. In a shared-store design, that may be a permitted context identifier; in an embedded-context design, it may be a validated, task-specific payload. The identifier itself is not authorization: the receiving agent still needs an access check.
Decide what the team should remember
Persistent memory is most useful when it preserves information that can improve future work and is appropriate to retain. Microsoft’s architecture recommends weighting and contextual retrieval rather than treating every past exchange as equally useful. Apple Machine Learning Research’s September 2026 publication describes retaining reusable task specifications, schemas, tool configurations, and output constraints while discarding session-specific reasoning traces.
- Good candidates: decisions that remain in force, user preferences relevant to future tasks, unresolved issues, reusable task specifications, validated schemas, tool configurations, and output constraints.
- Usually poor defaults: every transcript, transient reasoning traces, duplicated document contents, and session details with no clear future use.
- For each item, set a purpose and lifecycle: define its scope, owner, access rights, relevance or importance criteria, expiry or review rule, and deletion behavior.
Do not use the memory layer as an ungoverned mirror of an enterprise knowledge base. Keep source-of-truth business material in repositories or indexes with their own permissions; retrieve the relevant material when a task calls for it.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Apply access controls at agent boundaries
Shared context creates a privacy and security decision, not just a convenience. Microsoft Learn recommends limiting inter-agent context to what is necessary, validating typed payloads, using least privilege, and reconciling conflicting outputs. Put those controls into the design:
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →- Give each agent only the read and write permissions required for its role.
- Use explicit user, session, agent, subgroup, or tenant scopes instead of assuming all team members share one trust boundary.
- Validate the structure and permitted fields of incoming messages before an agent acts on them or commits them to shared memory.
- Audit cross-agent reads, writes, and handoffs, and make ownership of canonical state clear enough to investigate conflicting updates.
- Define expiry and deletion behavior so that access limits apply throughout an item’s lifecycle, not only at creation.
A coordinator can enforce selective disclosure when it builds each message, but this concentrates policy responsibility. A shared store can reduce message payloads, but requires sound access controls on the store and its credentials. Neither pattern removes the need to define and audit permissions.
Best Value
Choose storage for the workload, not by default
No universal storage engine or coordination pattern is established by the cited architecture guidance. Microsoft’s short-term-memory chapter notes that document-oriented NoSQL systems can suit flexible, nested session data; that is guidance, not a benchmark showing that NoSQL is superior for every workload.
Choose based on the data’s shape and access patterns, required scale and consistency, sensitivity, deployment topology, retention rules, and the team’s ability to operate the system. A common store is useful only if the team can manage its access boundary and availability. Separate stores are useful only if the team can handle synchronization, migration, and consolidated auditing where needed.
What published evaluations do—and do not—show
Two 2026 research publications report results relevant to memory design, but their figures describe specific evaluations rather than a universal comparison of architectures.
Free tools Windows power users keep installed
One-click scans. No signup required.
- Microsoft Research’s AIM results: 96.0% visibility-classification accuracy, 58.8% strict operation accuracy, and 70.5% state-aware operation accuracy. The AIM page reports three independent runs on MUMBench.
- Apple Machine Learning Research’s enterprise scenarios: 96% task completion with shared selective persistent memory, compared with 79% without memory and 71% with full-history persistence, across three enterprise deployment scenarios.
- Apple’s stated refresh and generation experiments: a 14× task-time reduction from a zero-token refresh mechanism and 97× lower per-invocation token cost with summary-driven generation. Apple also reports success in 12 of 12 trials on four public datasets.
These publisher-reported results do not establish that one memory topology will outperform another in every deployment. The reported settings, tasks, and metrics differ, so they should not be read as a head-to-head ranking of shared storage, message passing, and per-agent stores.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
