Designing Multi-Agent Systems

Part I establishes the theoretical foundations needed to understand multi-agent systems in an accessible format - defining what agents and multi-agent systems are, presenting a taxonomy of orchestration patterns, and articulating user experience design principles that apply to both end users and developers.

1. 01

   Understanding Multi-Agent Systems

   This chapter introduces agents as entities that can reason, act, communicate, and adapt - distinguishing them from models that only generate text. It defines multi-agent systems and guides readers through building their first multi-agent system: a poet-critic collaboration using round-robin orchestration, demonstrating how specialized agents work together through conversation until termination conditions are met.

2. 02

   Multi-Agent Patterns

   This chapter provides a taxonomy of multi-agent orchestration patterns, organizing approaches along a spectrum from explicit to emergent control. It presents deterministic workflow patterns (sequential, conditional, parallel, supervisor) that offer fine-grained control with predictable behavior, contrasted with autonomous patterns (plan-based, handoff, conversation-driven) where control flow is delegated to AI reasoning.

3. 03

   UX Principles for Multi-Agent Systems

   This chapter examines the user experience implications of multi-agent systems, framing the shift from traditional interface design to delegation design. It traces UI evolution from command-line to multimodal interfaces and articulates four essential UX design principles: capability discovery, cost-aware action delegation, observability and provenance, and interruptibility.

Part II transitions from theory to practice, teaching readers to build multi-agent systems from first principles by implementing a complete Python library called picoagents. The section covers agent fundamentals, workflow patterns, autonomous orchestration, and computer use agents—providing hands-on implementation experience with concepts introduced in Part I.

1. 04

   Building an Agent From Scratch

   This chapter implements the core agent execution loop from scratch, establishing design principles including async-first architecture, event-based streaming, component serialization, and graceful cancellation. It begins building the picoagents library progressively—starting with simple Q&A agents and advancing to multi-tool workflows, implementing model clients that support multiple LLM providers.

2. 05

   Building Computer Use Agents

   This chapter extends the agent framework to handle interface automation through computer use agents—systems that interact with user interfaces like web browsers and desktop applications. It implements action sequence generation, interface representation (DOM parsing, visual understanding, or hybrid approaches), and action execution using browser automation tools.

3. 06

   Building Multi-Agent Workflows

   This chapter implements workflow patterns as deterministic computational graphs where nodes represent computation units and edges define control flow. It builds type-safe workflow steps using Pydantic for validation, conditional edges enabling branching and parallel execution, and an intelligent workflow runner with dependency resolution, concurrent execution, and streaming observability.

4. 07

   Building Autonomous Multi-Agent Orchestration

   This chapter implements autonomous orchestration patterns where AI models drive coordination decisions at runtime. It establishes the orchestrator loop (select agent, execute turn, check termination, repeat) that underlies all coordination patterns, then builds composable termination conditions and a round-robin orchestrator with streaming observability—demonstrating the trade-off between workflow predictability and autonomous adaptability.

5. 08

   Building Modern Web Experiences for Agent Applications

   This chapter teaches how to build web interfaces for multi-agent systems, starting with a minimal ~200-line implementation using FastAPI and vanilla JavaScript with Server-Sent Events (SSE) for real-time streaming. It covers the two essential components of agent web applications (backend API and frontend UI), demonstrates UX principles like observability and capability discovery, explains when to choose SSE over WebSockets, and introduces the PicoAgents WebUI as both a development tool and reference implementation for studying production patterns with React.

6. 09

   But What About Multi-Agent Frameworks?

   This chapter presents ten core capabilities that distinguish effective multi-agent frameworks from basic implementations. Rather than comparing specific frameworks (which change constantly), it provides systematic evaluation criteria, practical questions to assess any framework, and decision guidelines for choosing between building from scratch versus adopting existing solutions.

Part III addresses the critical challenges of making multi-agent systems work reliably and responsibly through systematic evaluation, optimization, security, and ethical frameworks.

1. 10

   Evaluating Multi-Agent Systems

   This chapter introduces the concept of trajectories—complete sequences of reasoning and actions that unfold during task execution—as the fundamental unit of evaluation for models, agents, and multi-agent systems. It builds an evaluation framework integrated into the picoagents library, implementing metrics and judges that work across different system complexities, covering reference-based evaluation, reference-free evaluation using LLM judges, and practical evaluation planning strategies.

2. 11

   Optimizing Multi-Agent Systems

   This chapter explores techniques for improving multi-agent system performance and reliability in production. It identifies ten common failure modes—including inadequate instructions, model capability gaps, instruction-model mismatching, poor tool quality, inappropriate pattern selection, missing termination conditions, lack of memory, absent metacognition, missing evaluation infrastructure, and poor human delegation policies—providing concrete optimization strategies for each.

3. 12

   Protocols for Distributed Agents

   This chapter addresses distributed agent architectures where components run across separate execution contexts—different machines, regions, or organizations—communicating over networks. It explores Model Context Protocol (MCP) for standardized tool and context integration with agentic capabilities, and Agent-to-Agent Protocol (A2A) for cross-organizational collaboration.

4. 13

   Ethics and Responsible AI for Multi-Agent Systems

   This chapter examines how agentic AI ethics fundamentally differs from traditional AI ethics across four dimensions: controllability, action capability, domain scope, and verification. It analyzes agentic noise as platform imbalance, explores distributed responsibility challenges, emergent risks from agent interactions, and security as ethical imperative when agents can act.

Part IV demonstrates complete implementations of multi-agent systems applied to real-world business problems, showcasing workflow patterns, cost optimization, and production deployment strategies.

1. 14

   Answering Business Questions from Unstructured Data

   This chapter tackles the challenge of answering business questions that require semantic understanding across large volumes of unstructured text. It implements a four-stage sequential workflow demonstrating key production patterns: two-stage filtering to reduce costs, enforced structured outputs using Pydantic schemas to eliminate hallucination, checkpointing for resumability, independent component testing, and continuous cost monitoring.

2. 15

   Software Engineering Agent

   This chapter teaches the foundational pattern used by modern AI coding assistants like GitHub Copilot, Cursor, and Claude Code: agent capability emerges from tools + prompts + memory. It demonstrates building a software engineering agent that can autonomously write code, run tests, and iteratively improve solutions.