Multi-Agent Systems
Shared memory so agents can brief each other
Give a team of agents a shared, scoped memory pool, so findings pass between them without restating context in every handoff.
The problem
Multi-agent systems are usually assembled as a pipeline — planner, researcher, executor, reviewer — communicating only by passing messages. Every handoff either omits context the next agent needed or restates everything at cost. The researcher learns something the executor had no way to receive.
With MemorySync
MemorySync provides a shared memory pool scoped to the project, so any agent can write a finding and any authorised agent can retrieve it. Handoffs carry a reference rather than a transcript, and scope keeps each customer's pool separate.
How it works
- 1
Write
Each agent records its conclusions to the shared project pool.
- 2
Scope
Project and end-user scope define which agents can read what.
- 3
Retrieve
The next agent pulls what is relevant to its own step.
- 4
Coordinate
Work proceeds without passing full context in messages.
Message passing does not scale as coordination
In a pipeline of agents, context has to reach the agent that needs it. Passing it in messages leaves two options, both bad: send everything, and pay for it at every hop, or send a summary, and lose the detail the next agent needed.
Shared memory removes the choice. Agents write conclusions once and read what is relevant to their own step.
What belongs in the shared pool
- Findings other agents will need. What the researcher established, in a form the executor can act on.
- Decisions and their reasoning. So a reviewer can evaluate the decision rather than re-derive it.
- Environment facts. Discovered once by whichever agent hit them first.
- Standing conventions. Rules that apply to every agent in the system.
Working state stays out of the shared pool. It belongs to the agent that owns the task.
A handoff should carry a reference, not a transcript. That is only possible if both agents can read the same memory.
Scope is where this gets serious
Shared memory is useful precisely because it crosses agent boundaries, which makes the boundaries that must not be crossed important to enforce properly.
Two apply in almost every deployment. Agents acting for different customers must never share a pool. And an agent with narrow authority should not inherit a broader agent's context simply because both are in the same system.
MemorySync enforces organization, project, and end-user scope beneath the query, so these boundaries are structural rather than a filter each agent is trusted to apply.
Debugging a multi-agent failure
When a pipeline produces a poor result, the question is which agent acted on what. Without a record of retrieval per agent per step, that is guesswork.
Inspectable retrieval makes it answerable: for a given step, what did this agent know.
Keeping the pool useful as it grows
A shared pool written to by several agents grows quickly, and precision falls if every conclusion is retained verbatim. Deduplication on write and summarization keep it dense, so retrieval returns a small, high-signal set rather than everything every agent has ever concluded.
What you get
- Findings pass between agents without restatement
- Handoffs stay small
- Shared conventions apply to every agent
- Per-agent scope where roles must stay separate
- Inspectable retrieval per agent and step
- Customer pools remain isolated
Use cases
Build multi-agent systems with durable memory
Start on the free tier and test retrieval, scoping, and deletion against your own workload.
Start free. No credit card required.