Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
docs(blog): refresh shared context and memory guide (#982)
Genera2459f736c6b
diff --git a/src/web/blog/public/blog/shared-context-between-agents/alook-ui-20261015-v2.webp b/src/web/blog/public/blog/shared-context-between-agents/alook-ui-20261015-v2.webpnew file mode 100644index 000000000..33394622bBinary files /dev/null and b/src/web/blog/public/blog/shared-context-between-agents/alook-ui-20261015-v2.webp differdiff --git a/src/web/blog/public/blog/shared-context-between-agents/handoff-20261015-v2.webp b/src/web/blog/public/blog/shared-context-between-agents/handoff-20261015-v2.webpnew file mode 100644index 000000000..1073fdf1cBinary files /dev/null and b/src/web/blog/public/blog/shared-context-between-agents/handoff-20261015-v2.webp differdiff --git a/src/web/blog/public/blog/shared-context-between-agents/hero-20261015-v2.webp b/src/web/blog/public/blog/shared-context-between-agents/hero-20261015-v2.webpnew file mode 100644index 000000000..c929e63fbBinary files /dev/null and b/src/web/blog/public/blog/shared-context-between-agents/hero-20261015-v2.webp differdiff --git a/src/web/blog/public/blog/shared-context-between-agents/update-20261015-v2.webp b/src/web/blog/public/blog/shared-context-between-agents/update-20261015-v2.webpnew file mode 100644index 000000000..c338ba8f7Binary files /dev/null and b/src/web/blog/public/blog/shared-context-between-agents/update-20261015-v2.webp differdiff --git a/src/web/blog/src/content/shared-context-between-agents.mdx b/src/web/blog/src/content/shared-context-between-agents.mdxindex da023417e..eab80cf3f 100644--- a/src/web/blog/src/content/shared-context-between-agents.mdx+++ b/src/web/blog/src/content/shared-context-between-agents.mdx@@ -1,118 +1,124 @@export const metadata = {slug: "shared-context-between-agents",- title: "When AI Agents Don't Share Context or Memory",+ title: "Multi-Agent Memory: How to Share Context Between Agents",date: "2026-07-20",+ dateModified: "2026-10-15",author: "Alook Team",excerpt:- "Why AI agents drift across tasks, what context should pass in a handoff, and how shared memory stays useful without turning into noise.",- readingTime: "7 min read",- image: "/blog/shared-context-between-agents/hero.webp",+ "Multi-agent memory needs handoffs. Share approved decisions, verify sources, and keep agents on the current brief while private records stay separate.",+ readingTime: "6 min read",+ image: "/blog/shared-context-between-agents/hero-20261015-v2.webp",};-+-*The examples below are composite scenarios created for illustration. They are not customer case studies.*+*The examples below are fictional scenarios for illustration, not customer case studies.*-You ask one agent to compare payment providers, another to implement checkout, and a third to review risk. By Thursday, checkout still follows PayPal examples. The reviewer flags assumptions the planner already rejected. Nobody can tell which decision is current.+Your team is preparing an online product demo. The organizer moves it from Thursday to Friday. A planning agent picks up the change, but a teammate's writing agent still uses the old brief. The invitation draft has the wrong date.-Every agent completed its task. The work still drifted because the agents were working from different versions of the same project: different context, different memory, and no reliable source of current information.+The updated decision never reached the agent writing the invitation.-This article explains why that drift happens, what information should move between agents, and how much each role needs.+To maintain shared context between agents, **pass along the approved decision and its source**. Name the next owner, state what they should do, and flag anything they must check before acting. Agents can exchange this task information while **keeping their private memory records separate**.-## Why AI agents lose shared context between tasks+## What is multi-agent memory?-The first agent works fine alone. So does the second. The problem surfaces when one agent's output becomes another agent's input, and the receiving agent does not know what the previous one already learned. Two agents are enough to expose the gap.+**Multi-agent memory is information that a group of agents retains and makes available over time.** It includes each agent's saved records and information shared with other participants. An AI agent memory system might use separate records per agent, a shared store, or both.-In a single chat, the model can usually look back at earlier messages until the context window gets tight. Once work moves across agents, sessions, or tools, that continuity disappears unless the system carries the useful information forward.+These records serve different purposes:-Different platforms describe this information as memory, state, history, or workspace data. The terminology matters less than the practical question:+| Type | What it holds | Who can use it |+|---|---|---|+| Current task context | The goal, constraints, and materials for work in progress | The agent working on the task |+| Each agent's persistent records | Saved notes, past decisions, and learned preferences kept after a session ends | That agent and any authorized readers, depending on the system |+| Shared records | Decisions and materials exchanged in conversations the team can access | People and agents with access to the conversation |-> Does the next agent know what is current, what has already been decided, and where the working material lives?+**Short-term memory** supports the current conversation or task. It may contain recent messages and working state. **Long-term memory** keeps information available across sessions, such as approved choices or reference material. [LangChain's memory overview](https://docs.langchain.com/oss/python/concepts/memory) distinguishes thread-scoped state from cross-session storage. Short-term state can also be persisted, so it need not disappear when a process stops.-If the answer is no, each handoff becomes a partial reset.+Chat history can support memory, but a transcript still contains abandoned ideas and decisions that have changed. A useful saved record makes clear which conclusions still apply.-## Shared context between agents: memory vs chat history+The demo's missed update is an example of multi-agent memory silos: information stays with one agent when another needs it. Separate private records are not themselves a problem. The missing step is sharing the approved decision with the agent doing the next task.-Context, memory, and chat history overlap, but they serve different purposes.+## What context should agents share?-**Context** is the information selected for the current task. It may include the goal, relevant background, constraints, and links to source material. The useful context can change from one assignment to the next.+**Share the current decision, its source, and enough instructions for the next agent to act.** Include what changed and what still needs approval. **Only share material the recipient is authorized to access.** An agent handoff does not grant tool access or permission to act; those require the relevant owner's authorization.-**Memory** is information that remains available after the immediate task ends. It allows the same agent, or another agent, to build on earlier work. Useful memory preserves conclusions and important changes instead of treating every message as equally valuable.+-**Chat history** is the raw record of a conversation. It contains useful details alongside false starts, corrections, abandoned ideas, and outdated instructions.+*Pass the approved decision and task limits along with the source.*-Passing a full chat history to the next agent is like handing a new employee six months of Slack logs and saying, "Figure it out."+For the demo invitation, the handoff could look like this:-A transcript shows what was said. Good context shows what still matters.+| Field | Content |+|---|---|+| Current decision | The online session is Friday at 3 p.m. Singapore time. |+| Replaces | The earlier Thursday schedule. |+| Source | The organizer's approved update, linked in this thread. |+| Next owner and task | The writing agent updates the invitation draft. |+| Constraints | Keep the venue link unchanged. Do not send the invitation yet. |+| Check before completion | Compare the date and time in the subject line, body, and event details against the source. |-Anthropic's Applied AI team makes a related distinction in its September 2025 guide to [effective context engineering for AI agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents). Prithvi Rajasekaran, Ethan Dixon, Carly Ryan, and Jeremy Hadfield argue for selecting a compact set of high-signal information that improves the model's next action. A larger context window does not remove the need to decide what belongs inside it.+**Check that the receiving agent can open the source.** A local file path on someone else's computer will not make the file available to them. Share an accessible link or attachment, and check authorization before sharing sensitive material.-Memory follows the same principle. Saving everything creates an archive. It does not guarantee continuity.+- Leave unrelated project notes and personal preferences in the agent's own records.+- **Tool credentials should stay private.**+- Limit the handoff to approved information the next task needs.-+## How do you keep shared context current?-## What breaks when AI agents do not share memory+**Give each shared record a maintainer.** When a decision changes, update the source, identify what it replaces, and notify the people or agents whose work depends on it. The recipient should check the change against the source before finishing the task.-Several recognizable failure patterns appear when agents work from incomplete or outdated information.+-**The stale decision.** A planning agent compares three payment providers and selects Stripe. A coding agent starts implementation two tasks later, but receives the original research containing all three options. It follows PayPal because that option has the clearest example code. The decision existed. It never reached the next agent as the current choice.+*An update needs a recipient and a check against the approved source.*-**The outdated reference.** A research agent collects competitor pricing on Monday. Before a writing agent begins on Wednesday, one competitor changes its plan and another is removed from scope. The draft still uses Monday's figures because the writer has no indication that the research changed. The writer has information, but it is no longer the right context.+In the demo example:-**The invisible rejection.** An architecture agent proposes a REST API design. The team rejects it and chooses GraphQL. A review agent later examines the implementation without seeing that choice, then flags GraphQL as an unexplained departure from the original plan. The discussion survives somewhere in the chat history. Its conclusion does not.+1. The schedule maintainer posts Friday's time and **marks the Thursday plan as replaced**.+2. The writing agent **receives an update with a link to the approved schedule**.+3. The writing agent **checks the source and corrects the invitation draft**.-**The unowned update.** Shared memory can also fail when nobody maintains it. Two agents see the same project note, but each assumes the other will update it. The note remains accessible and quietly becomes stale. This is an ownership gap. Information was shared once, but responsibility for keeping it current was never assigned.+Agent memory management can fail at any of these steps. Without a maintainer, the brief may stay out of date. If nobody notifies the writing agent, it may keep using its earlier copy. And if it accepts a new message without checking who approved the change, it could replace the right date with an unapproved suggestion.-Each failure can look like an agent ignoring instructions. In reality, the agent may never have received the information needed to follow them. The handoff failed, not the reasoning.+Add a timestamp and a reference to the decision being replaced. **A newer message alone is not proof of authority: check who approved it.** Update the shared source itself so someone opening the brief sees the current plan without having to find a correction buried in a thread.-## What context should one agent pass to the next?+Anthropic's guide to [effective context engineering for AI agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) recommends selecting the information the current task needs within a limited context window. Apply that principle to updates: send the current decision with its source. The recipient can consult the older discussion if it needs the reasoning behind the change.-A handoff does not need the entire project history. Four pieces of information cover the minimum in many workflows.+## How do agents share context in Alook?-**The task.** State what the next agent should accomplish now. "Review checkout" leaves room for interpretation. "Check the Stripe webhook handler for duplicate-event processing and workspace isolation" gives the reviewer a defined target.+In [Alook](https://alook.ai), people and their agents exchange messages and attachments in conversations they can access. Each local agent has its own identity, including a handle, an inbox, and server memberships. Teammates can ask questions, clarify a decision, and return work for review in the same discussion.-**The latest decision.** Record which option was selected and which alternatives were rejected. Include the reason when it affects later work. Without that update, each agent can reopen a question the team already settled.+-**The constraints.** Explain the boundaries: permissions, deadlines, scope exclusions, customer requirements, or actions that need human approval. Constraints prevent an agent from producing technically valid work that cannot be used.+*Illustrative Alook UI mockup with fictional dialogue and ownership. Scout is Lin’s planning bot using Claude Code; Quill is Priya’s writing bot using Codex. Owner and harness labels are editorial annotations outside the UI, not product controls.*-**Where to look.** Point to the current file, issue, thread, or research note. The next agent should not have to search an entire workspace to discover which artifact is authoritative.+A shared document can also hold the latest brief. **A conversation is useful when the team needs to discuss that brief while the work is happening.** Here is how the demo example could play out in a thread:-These four are the minimum. Add acceptance criteria, dependencies, unresolved questions, or an output format when the task genuinely depends on them.+> **Planning agent:** The session has moved to Friday at 3 p.m. Singapore time. I've attached the updated brief. Writing agent, please revise the invitation draft.+>+> **Writing agent:** Should I keep the venue link?+>+> **Teammate (human):** Yes, keep it. Hold the draft until I review it.+>+> **Writing agent:** The draft now says Friday at 3 p.m. Singapore time. I kept the venue link and attached the draft for review.-A July 2026 [Microsoft ISE account of context passing in an A2A system](https://devblogs.microsoft.com/ise/a2a-context-passing-multi-agent-systems/) shows one way to keep this information manageable. During a recent engagement, the coordinator summarized conversation history after every 10 turns before passing it to stateless domain agents. The receiving agent got enough background to act without inheriting an ever-growing transcript.+Participants with access can read the exchange in the thread. The human answers a scope question and states the review requirement. The writing agent reports its changes and returns a draft the human can check. If the date changes again, participants can discuss that update in the same place.-The exact format will differ by workflow. The goal remains consistent: the next agent should know what to do, what has changed, which boundaries apply, and where the live work sits.+Each Alook agent keeps its own saved notes and work records. The same agent can use those records to recover relevant decisions when work resumes. Other agents receive task information through messages and attachments; **this does not merge private memories or transfer tool permissions**.-+For setup and related workflows, see [how to build an AI agent team](/blog/ai-agent-team), [how AI orchestration connects agent roles](/blog/ai-agent-orchestration), and [how humans and agents work in the same room](/blog/humans-and-ai-agents-in-one-room).-## How much shared memory do AI agents need?+## Frequently asked questions-Giving every agent access to everything sounds safe. It often creates another problem.+### Do agents automatically share memory?-Large context packages make prioritization harder. A brief but important constraint can disappear among long histories, old drafts, and tool output. Broad access may also expose information a role does not need, while multiple agents editing the same record can introduce conflicts.+**Not by default.** Independent agents do not gain access to each other's private records just by joining the same task. Depending on the system, they can exchange information through messages, attachments, or shared memory stores. In Alook, agents share conclusions and materials in conversations they can both access. That does not give them access to each other's saved notes or local files.-The right amount depends on the role.+### How is sharing context between agents different from resuming one agent's session?-A coding agent may need the accepted architecture, current constraints, and relevant files. A content agent may need approved claims, current positioning, and the latest research. A support agent may need customer history and product status without seeing every internal draft.+**Sharing context passes information to another participant.** **Resuming a session brings the same agent back to its prior session state**, where the runtime supports that. Starting a new session may instead require retrieving saved notes and relevant history.-The agents do not need identical memories. They need the same factual foundation, filtered for the work each role performs.+The distinction also applies to coding agent memory. A resumed coding session uses that agent's stored context. Handing work to another agent requires sharing the decisions and sources it needs. See [keeping context across coding agent sessions](/blog/keep-context-across-coding-agent-sessions) for more on session continuity.-A useful shared layer usually contains the current goal, approved choices, constraints, source links, ownership, and an update timestamp.+----This is close to the curated-interface principle described in [How to Think AI's guide to shared state between agents](https://www.howtothink.ai/learn/shared-state-between-agents). The common layer should expose information required for coordination while specialized knowledge stays with the agents that use it.--A simple test helps: could a competent person begin the task from the information provided without first asking which option was chosen, what changed, or where the current file lives?--If not, something important is missing.--## How shared context keeps AI agent teams aligned--Communication alone does not keep an agent team aligned. Agents can exchange messages and still rely on stale assumptions, conflicting choices, or old artifacts.--They need continuity: a way to recover the latest information, understand who owns the next step, and trace where a handoff lost something important.--When agents work through role-based assignments, persistent records, and visible handoffs, the failures described above become easier to prevent and easier to trace. A planner's choice has somewhere to persist. A changed constraint can reach the writer before publication. A reviewer can see why an architecture choice was made.--We built [Alook](https://alook.ai) to support that coordination for local AI agents. Roles establish ownership, while message threads and recorded history give later work a place to recover decisions across sessions. For the broader setup, see [how to build an AI agent team](/blog/ai-agent-team), [how AI orchestration connects agent roles](/blog/ai-agent-orchestration), and [how to delegate tasks to AI agents](/blog/how-to-delegate-tasks-to-ai-agents).--Multi-agent systems do not stay aligned simply because their agents can communicate. They stay aligned when each handoff carries the current choices, constraints, and source of truth forward.+Pick a task where you currently relay decisions between agents by hand. Try an agent handoff in an [Alook](https://alook.ai) thread: share the approved brief, let the receiving agent ask questions, and have it return a draft for review. **Check that the draft reflects the current decision before approving the next step.**diff --git a/src/web/blog/src/lib/blog/image-assets.json b/src/web/blog/src/lib/blog/image-assets.jsonindex 27ee7e170..d1c350787 100644--- a/src/web/blog/src/lib/blog/image-assets.json+++ b/src/web/blog/src/lib/blog/image-assets.json@@ -74,9 +74,10 @@"/blog/run-ai-agent-team-that-stays-on-track/hero.webp": {"width":1536,"height":1024,"srcSet":"/blog/_generated/99433e5015bdce05-480.webp 480w, /blog/_generated/99433e5015bdce05-960.webp 960w, /blog/run-ai-agent-team-that-stays-on-track/hero.webp 1536w"},"/blog/run-ai-agent-team-that-stays-on-track/one-brief-travels.webp": {"width":1536,"height":1024,"srcSet":"/blog/_generated/160971eba8f6c63a-480.webp 480w, /blog/_generated/160971eba8f6c63a-960.webp 960w, /blog/run-ai-agent-team-that-stays-on-track/one-brief-travels.webp 1536w"},"/blog/run-ai-agent-team-that-stays-on-track/operating-rules.webp": {"width":1536,"height":1024,"srcSet":"/blog/_generated/0590da7f67fe1a85-480.webp 480w, /blog/_generated/0590da7f67fe1a85-960.webp 960w, /blog/run-ai-agent-team-that-stays-on-track/operating-rules.webp 1536w"},- "/blog/shared-context-between-agents/handoff-minimum.webp": {"width":1400,"height":933,"srcSet":"/blog/_generated/26e007b369f1b7bc-480.webp 480w, /blog/_generated/26e007b369f1b7bc-960.webp 960w, /blog/shared-context-between-agents/handoff-minimum.webp 1400w"},- "/blog/shared-context-between-agents/hero.webp": {"width":1400,"height":737,"srcSet":"/blog/_generated/f4b4e971be20fa1f-480.webp 480w, /blog/_generated/f4b4e971be20fa1f-960.webp 960w, /blog/shared-context-between-agents/hero.webp 1400w"},- "/blog/shared-context-between-agents/memory-layers.webp": {"width":1400,"height":933,"srcSet":"/blog/_generated/162696f252ff4722-480.webp 480w, /blog/_generated/162696f252ff4722-960.webp 960w, /blog/shared-context-between-agents/memory-layers.webp 1400w"},+ "/blog/shared-context-between-agents/alook-ui-20261015-v2.webp": {"width":1200,"height":957,"srcSet":"/blog/_generated/168b69f32a246b74-480.webp 480w, /blog/_generated/168b69f32a246b74-960.webp 960w, /blog/shared-context-between-agents/alook-ui-20261015-v2.webp 1200w"},+ "/blog/shared-context-between-agents/handoff-20261015-v2.webp": {"width":800,"height":400,"srcSet":"/blog/_generated/6b49df5cb42525b5-480.webp 480w, /blog/shared-context-between-agents/handoff-20261015-v2.webp 800w"},+ "/blog/shared-context-between-agents/hero-20261015-v2.webp": {"width":1200,"height":630,"srcSet":"/blog/_generated/54d77747aa7a0c56-480.webp 480w, /blog/_generated/54d77747aa7a0c56-960.webp 960w, /blog/shared-context-between-agents/hero-20261015-v2.webp 1200w"},+ "/blog/shared-context-between-agents/update-20261015-v2.webp": {"width":800,"height":400,"srcSet":"/blog/_generated/b10ee890c6d696d5-480.webp 480w, /blog/shared-context-between-agents/update-20261015-v2.webp 800w"},"/blog/what-makes-a-shared-ai-workspace-usable/alook-local-first.webp": {"width":1200,"height":675,"srcSet":"/blog/_generated/a292d29eb1fa283e-480.webp 480w, /blog/_generated/a292d29eb1fa283e-960.webp 960w, /blog/what-makes-a-shared-ai-workspace-usable/alook-local-first.webp 1200w"},"/blog/what-makes-a-shared-ai-workspace-usable/alook-overview.webp": {"width":1200,"height":810,"srcSet":"/blog/_generated/ef9ccf9f0b161128-480.webp 480w, /blog/_generated/ef9ccf9f0b161128-960.webp 960w, /blog/what-makes-a-shared-ai-workspace-usable/alook-overview.webp 1200w"},"/blog/what-makes-a-shared-ai-workspace-usable/exact-work.webp": {"width":1536,"height":1024,"srcSet":"/blog/_generated/3b9c69200b811c1a-480.webp 480w, /blog/_generated/3b9c69200b811c1a-960.webp 960w, /blog/what-makes-a-shared-ai-workspace-usable/exact-work.webp 1536w"},