Engineering Multi-Agent Systems

Resources

• Inside Anthropic’s multi-agent research system — Anthropic describes its lead-agent and specialist design, delegation prompts, parallel research, context management, and evaluation. Use it as an engineering case study in assigning ownership and bounding delegated work, not as a claim that more agents always improve results. https://www.anthropic.com/engineering/multi-agent-research-system

• Choose who owns orchestration — OpenAI compares model-driven coordination with code-driven orchestration, including agents as tools, handoffs, and parallel execution. This helps distinguish a manager that retains responsibility for the result from a transfer of conversational control. https://openai.github.io/openai-agents-python/multi_agent/

• Collaboration modes and return behavior — Google’s ADK documentation compares collaboration modes, context behavior, and how control returns to a parent agent. Use it to make delegation contracts explicit: whether a specialist continues a conversation, completes a task, or returns a bounded result. https://adk.dev/workflows/collaboration/

• Parallel workers need a merge point — ADK’s parallel-agent guide demonstrates independent researchers followed by a synthesis agent, with separate output keys for intermediate results. It makes dependencies and synchronization concrete while showing why shared-state writes need deliberate coordination. https://adk.dev/agents/workflow-agents/parallel-agents/

• Shared state has scope and update rules — ADK documents session state, scope prefixes, and event-based state updates. Use it to decide what teammates can see and persist, instead of assuming that separate agent contexts imply separate application state. https://adk.dev/sessions/state/

• Artifacts are a communication channel — ADK’s artifact documentation describes named, versioned data managed separately from conversational state. It is useful for designing handoffs that return reports, files, and references rather than copying every intermediate result into every agent’s context. https://adk.dev/artifacts/

• Agent-to-agent communication contracts — The A2A specification defines agent discovery, messages, tasks, artifacts, status changes, and asynchronous interactions. It provides a protocol-level reference for bidirectional exchange and return contracts without requiring access to another agent’s internal memory or tools. https://a2a-protocol.org/latest/specification/

• Checkpoint shared work before continuing — LangGraph documents threads, checkpoints, state snapshots, stores, and recovery behavior. Use it to reason about what a coordinator can observe or resume after partial completion, and to distinguish persistent shared knowledge from one agent’s working context. https://docs.langchain.com/oss/python/langgraph/persistence

• Why multi-agent systems fail — The MAST paper develops a failure taxonomy from annotated multi-agent execution traces. It supplies counterexamples for role ambiguity, inter-agent misalignment, and verification failures, helping turn coordination problems and unresolved conflicts into explicit evaluation cases. https://arxiv.org/abs/2503.13657

• Evaluate outcomes, not convincing transcripts — Anthropic explains tasks, trials, graders, transcripts, and final environment state, with deterministic, model-based, and human grading approaches. Use it to assess both specialist contributions and the team’s actual result, rather than trusting the coordinator’s completion message. https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents

• Offline tests and online evaluation serve different jobs — LangSmith distinguishes dataset-based pre-deployment evaluation from production-run monitoring and compares code, LLM, and human evaluators. This gives the lesson a concrete way to separate regression checks from live quality signals and calibrate model-based judgments. https://docs.langchain.com/langsmith/evaluation-concepts

• Version the evaluation dataset — LangSmith documents dataset versions, tags, filtered views, and splits. Use it to keep comparisons meaningful when agent roles, prompts, models, or coordination logic change, and to preserve failure cases without silently changing the benchmark. https://docs.langchain.com/langsmith/manage-datasets

• Trace delegation across the whole run — OpenAI’s tracing documentation covers agent, generation, tool, handoff, and custom spans, including grouping and sensitive-data controls. It supplies the execution evidence needed to debug coordination failures and attribute latency or cost before changing the team architecture. https://openai.github.io/openai-agents-python/tracing/