Memory Interaction Patterns in Multi-Agent Systems

Question 1

What is the core idea of “memory interaction” in multi-agent systems?

Answer 1

How agents share, isolate, or transfer memory, which strongly affects collaboration quality and reliability.

Question 2

Why does memory interaction “dramatically affect” collaboration?

Answer 2

It changes what context each agent sees and what information flows back, which changes reasoning quality, cost, and confusion risk.

Question 3

What is the simplest memory interaction pattern described?

Answer 3

Message passing.

Question 4

What is “message passing” between agents?

Answer 4

One agent sends a task request and receives a final response, without sharing full history.

Question 5

What is the human analogy for message passing in the reading?

Answer 5

Sending an email to a colleague and receiving their answer.

Question 6

In message passing, what does the calling agent typically receive?

Answer 6

Only the final result (not the full process).

Question 7

Why is message passing often preferred for simple delegation?

Answer 7

It keeps agents isolated and focused, minimizing irrelevant context.

Question 8

In the basic call_agent example, what memory does the invoked agent start with?

Answer 8

A fresh memory instance.

Question 9

Why create fresh memory for the invoked agent in message passing?

Answer 9

To prevent mixing histories and keep the invoked agent focused on the request.

Question 10

In basic message passing, what part of the invoked agent’s memory is returned?

Answer 10

Only the final memory item.

Question 11

When does message passing work best?

Answer 11

When the caller only needs the final answer, not the reasoning process.

Question 12

What is an example use case for message passing from the reading?

Answer 12

A project manager asks a scheduling agent for a meeting time and only needs the scheduled time.

Question 13

What is the main weakness of message passing?

Answer 13

Output quality depends heavily on how well the task request is written.

Question 14

What is “Memory Reflection”?

Answer 14

A pattern where the caller receives not just the result, but also the invoked agent’s process as memories.

Question 15

What is the human analogy for memory reflection?

Answer 15

Asking a colleague to explain how they arrived at their answer, not just the answer.

Question 16

How is memory reflection implemented in the example?

Answer 16

Copy all memory items from the invoked agent into the caller’s memory.

Question 17

In call_agent_with_reflection, where does the caller’s memory come from?

Answer 17

action_context.get_memory()

Question 18

In reflection, how can copied memories be labeled to show their source?

Answer 18

Add a type field like “{agent_name}_thought”.

Question 19

Why mark the memory source during reflection?

Answer 19

So the caller can distinguish which agent produced which memories.

Question 20

What does call_agent_with_reflection return besides result?

Answer 20

How many memories were added (memories_added).

Question 21

When is memory reflection valuable?

Answer 21

When the caller needs to understand the reasoning process to use the result well.

Question 22

What is an example use case for reflection from the reading?

Answer 22

A research coordinator wants to see the analysis process from a data analysis agent.

Question 23

What is a downside of memory reflection?

Answer 23

It can flood the caller with extra context and increase complexity/token cost.

Question 24

Why might you “leave off the last memory item” when copying memories?

Answer 24

To avoid duplicating the final result if it’s already returned separately.

Question 25

What is “Memory Handoff”?

Answer 25

Passing the caller’s existing memory to another agent so it can continue with full context.

Question 26

What is the human analogy for memory handoff?

Answer 26

A colleague taking over a project and needing the full history.

Question 27

In memory handoff, what memory does the invoked agent receive?

Answer 27

The existing current memory (shared memory).

Question 28

In the hand_off_to_agent example, what is passed as memory?

Answer 28

current_memory from action_context.get_memory()

Question 29

What is the core benefit of memory handoff?

Answer 29

The next agent can pick up seamlessly using full context of what happened so far.

Question 30

When is memory handoff most useful?

Answer 30

Complex tasks where history and context are crucial for correctness.

Question 31

What is an example use case for memory handoff from the reading?

Answer 31

Customer service handing off to technical support who needs the full issue history.

Question 32

What is a major downside of handing off full memory?

Answer 32

The invoked agent may see lots of irrelevant history, increasing distraction and cost.

Question 33

How do these patterns differ in “context selection”?

Answer 33

Message passing: caller chooses context; reflection: caller gets process; handoff: invoked agent gets full history.

Question 34

What is the key design question when choosing a memory interaction pattern?

Answer 34

Do we only need the final answer, do we need the process, or does the next agent need full context to continue?

Question 35

How does message passing affect modularity?

Answer 35

It keeps agents cleanly separated because only a request and response cross the boundary.

Question 36

How does memory reflection affect debuggability?

Answer 36

It improves visibility into the invoked agent’s process by copying its work trail into shared memory.

Question 37

How does memory handoff affect continuity?

Answer 37

It maximizes continuity by letting the new agent inherit the full working context.

Question 38

What is a practical risk of sharing too much memory back to the caller?

Answer 38

The caller gets “polluted” with details it doesn’t need, which can reduce clarity and predictability.

Question 39

What is the overall tradeoff across the three patterns?

Answer 39

More shared memory can improve context and transparency, but increases complexity, cost, and distraction risk.