Book Review: Agentic Design Patterns

Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems by Antonio Gullí (Springer, about 50 euros; a PDF is on GitHub).

Overall verdict

Some of its high-level concepts still hold up, but the text descriptions are more useful than the code examples. I prefer Pydantic AI to the frameworks used in the book (LangChain, Google ADK, and CrewAI), and found some examples distracting. The sections promoting Google products, particularly Agent2Agent and the ADK, can be skipped; the author’s bias is fairly clear given that they work at Google.

Chapter 1: Prompt Chaining

Useful concept, although LangChain Expression Language feels like overkill here.

Chapter 2: Routing

Useful concept: classify each request first, then send it to the prompt, tool or agent built for that kind of request. Since publication, Anthropic finds that a router in front of a fixed pipeline mostly does work current models no longer need done for them.

Chapter 3: Parallelization

Useful for reducing latency, though the value depends on how important latency is in the specific use case.

Chapter 4: Reflection

Useful for advanced agentic systems, though in many settings reasoning models already critique and revise their own draft before answering, which covers the classic self-critique loop.

Chapter 5: Tool Use

When the book was written, agent skills were still in their infancy, which makes this chapter feel somewhat outdated.

Chapter 6: Planning

Useful for advanced agentic systems. If the steps are known in advance, a fixed chain (Chapter 1) is often enough; when they aren’t, planning pays off, as in Cursor’s “Plan Mode”.

Chapter 7: Multi-Agent

This chapter is thin relative to how much the field has moved since publication. Cursor’s experiments with self-driving codebases are particularly noteworthy. Since then, Anthropic reports that one agent with skills and tools often beats a team of subagents.

See also Pydantic AI’s multi-agent patterns. Another useful search term is “agent swarms.”

Chapter 8: Memory Management

This is one area where agent frameworks differ meaningfully. In Pydantic AI, short-term memory is the message history you pass between runs; long-term memory is usually a store you hand to tools via dependencies.

Chapter 9: Learning and Adaptation

This seems overhyped and of little use in production.

Chapter 10: Model Context Protocol (MCP)

The distinction between tool use and MCP is not explained clearly. Conceptually, MCP is a structured way to implement tool use: it defines a protocol for how an agent interacts with tools, while tool use can also be implemented ad hoc.

In practice, the conceptual difference between the two is not very important.

Since publication, several projects have the model write code that calls tools, instead of calling tools one at a time:

Chapter 11: Goal Setting and Monitoring

Think of the TODO list in Cursor’s “Plan Mode” as a practical example of goal setting and monitoring.

Since publication, Karpathy’s autoresearch has taken this further with a self-driving codebase that conducts deep-learning research. The human sets the goal in program.md; the agent edits the training code, runs short experiments, and keeps only the changes that improve the metric.