PixioLab
Cover of Guide 02, Agentic Design Patterns

Guide 02 · 47 pages · 16 chapters

Agentic Design Patterns

How to design, build, evaluate and deploy agents.

By PixioLab

Included in the full program and the guide library. See the 45-day roadmap.

What's inside

  1. 01

    What an agent is, and when to build one

    Most confusion about agents comes from vague words. This chapter fixes the vocabulary: what separates a workflow from an agent, how the patterns in this guide fit together, the seven parts every agent has, and the short loop at the center of all of them.

    1.1 Calls, workflows and agents · 1.2 Two families, five core patterns · 1.3 The seven parts of an agent · 1.4 The loop, in code · 1.5 When to build an agent, and when not to

  2. 02

    Tool use: the ReAct loop

    The base loop every other pattern builds on. The model reasons about what to do, calls a tool, reads the result and reasons again. Most of the work is in the tools and in the error path, not in the loop.

  3. 03

    Planning

    Separate thinking about the whole job from doing each piece. A planner writes the plan as data, an executor works through it, and a failure sends the remaining work back to be re-planned.

  4. 04

    Reflection

    Add a review step between generating an output and delivering it. A generator drafts, a critic checks the draft against explicit criteria, and failures go back for revision until the output passes or a cap is hit.

  5. 05

    Routing

    Classify each request and send it to the handler built for that kind of request. Routing keeps every specialist simple while the system covers a wide range of inputs, and it is one of the largest cost levers you have.

  6. 06

    Multi-agent systems

    A supervisor owns the task, splits it, delegates the pieces to worker agents running in parallel, and combines what they return. Powerful for broad, separable work, and the most expensive pattern in this guide.

  7. 07

    More workflow, reasoning and coordination patterns

    The five core patterns are the building blocks. These are what you combine them with, grouped by the problem they solve. None of them repeats a core pattern.

    7.1 Workflow patterns · 7.2 Reasoning patterns · 7.3 Coordination patterns

  8. 08

    Controls and knowledge

    Controls keep an agent inside the lines: budgets, guardrails, human approval and tracing, none of them optional in production. Knowledge patterns decide what the agent remembers and retrieves. Context compaction is covered with the other long-running techniques in Section 9.2.

    8.1 Budgets and termination · 8.2 Guardrails · 8.3 Human-in-the-loop · 8.4 Graphs and tracing · 8.5 Memory · 8.6 Agentic RAG

  9. 09

    Context and tools

    Patterns give an agent its shape. Context and tools decide whether it works on real inputs. Many failures that look like weak reasoning turn out to be a cluttered context or a badly described tool.

    9.1 Context engineering · 9.2 Techniques for long-running agents · 9.3 Tool design

  10. 10

    State, structured outputs and models

    An agent is a program: it needs typed state it can resume from, outputs code can parse, and models chosen per step on evidence, including what reasoning models change.

    10.1 State management · 10.2 Structured outputs · 10.3 Model selection · 10.4 Reasoning models and extended thinking

  11. 11

    Protocols and frameworks

    MCP standardizes how agents reach tools and data; A2A, how agents from different teams talk. Frameworks package the loop, state and tracing. Know what each does for you and what it costs.

    11.1 The Model Context Protocol (MCP) · 11.2 MCP security · 11.3 Agent-to-agent protocols (A2A) · 11.4 The framework landscape

  12. 12

    Evaluating agents, in brief

    The essentials while building: did the task succeed, was the path acceptable, and where did a failed run first go wrong. Datasets, judges, statistics and monitoring live in Guide 03.

    12.1 Task success: check the end state · 12.2 Trajectory checks: rules over the trace · 12.3 Read the trace, find the first wrong step

  13. 13

    Deploying agents

    A working notebook is not a product. This is the runtime, durability, reliability, security, cost and rollout work that turns an agent into a system you can put in front of users.

    13.1 Runtime architecture · 13.2 Long-running and durable execution · 13.3 Reliability · 13.4 Security · 13.5 Cost and latency · 13.6 Rollout, oversight and agent UX

  14. 14

    Capstone: a reference architecture

    How the pieces combine in one realistic system, what to check before you ship, and the failures you will most likely meet. Every pattern named here is drawn in the figure.

    14.1 A production support agent · 14.2 The production checklist · 14.3 Common failures and fixes

  15. 15

    Cheat sheet and next steps

    Every pattern on one page, then where to practice. To choose, climb the ladder in Section 1.5 and add the four controls to anything that loops.

    15.1 Pattern selection cheat sheet · 15.2 Where to go next

  16. 16

    Sources and further reading

    The primary material behind this guide, checked in November 2026.