What is the human analogy used to explain agent delegation?
A boss delegating a task to an intern or expert.
What is the simplest form of agent-to-agent coordination described?
Message passing.
In message passing, what is the “message” from the boss to the intern?
The task description (requirements) sent to the intern.
In message passing, what is the “message” from the intern back to the boss?
The result of the work (e.g., a report section).
Why is message passing considered simple?
It’s just “send task → do work → return result.”
What is the biggest dependency in message passing?
The quality of the task description.
Why does task description quality matter so much?
The delegate’s output quality is directly dependent on the clarity and completeness of the task description.
What common mistake can happen when tasks are sent via tool calls (e.g., JSON fields)?
The sender writes overly short task descriptions because the field looks “small.”
Why can short task descriptions be harmful?
They omit context and requirements the delegate needs to do a good job.
In multi-agent systems, what does the calling agent need to be good at?
Writing rich task descriptions for handoffs.
What does a call_agent or handoff tool do conceptually?
It sends a task message to another agent and receives a result.
Why might a coordinator not know what context an expert needs?
The coordinator lacks deep domain knowledge about the expert’s work.
What does this create for task-based delegation?
A context-selection challenge: what information should be included in the message?
What is an alternative to carefully crafting a rich task message?
Hand off the entire work log/memory so the expert can choose relevant context.
What is the “work stream” in the analogy?
The ongoing log of work, inputs, and drafts collected so far.
What does “handoff the entire log” enable?
The expert can read the history and decide what information is relevant.
In agent systems, what plays the role of the “work log”?
Memory (conversation history + tool actions + results).
What is “memory handoff” in this lesson?
Passing the agent’s memory to another agent so it can use full context.
What is a key benefit of memory handoff?
The specialist can select the context it needs without the coordinator guessing.
What is the simplest memory-handoff return style described?
The invoked agent reads the memory and adds one final result item back.
Why might you want more than just the final result from the specialist?
To inspect intermediate work and reuse useful discoveries.
What is a “fully shared memory” model?
The delegate sees the full memory, adds intermediate steps to it, and returns the complete updated log.
What does fully shared memory allow the boss/coordinator to see?
Not just the final answer, but the delegate’s process and intermediate findings.
What is a key upside of fully shared memory?
Transparency into the delegate’s work and richer collaboration.