---
title: "Book Review: Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems"
pubDate: 2026-03-29T00:00:00.000Z
updatedDate: 2026-03-29T00:00:00.000Z
tags:
  - AI
image: /images/blog/agentic-design-book-review/featured.png
---

# Introduction
Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems
https://github.com/DanieleSalatti/AgenticDesignPatterns/blob/main/Agentic_Design_Patterns.pdf

https://link.springer.com/book/10.1007/978-3-032-01402-3. cost of 50 Euros.

# Part One

## Chapter 1: Prompt Chaining 
Useful concept, although LangChain Expression Language feels like overkill here.

## Chapter 2: Routing

Very useful concept: divide and conquer.

## Chapter: Parallelization

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

## Chapter 4: Reflection

Useful concept to consider for advanced agentic systems.

## Chapter 5: Tool Use

At the time of writing, agent skills were still in their infancy, which makes this chapter feel somewhat outdated.

## Chapter 6: Planning

Useful concept to consider for advanced agentic systems. If we have a-priori knowledge of the steps needed to solve a problem, planning should be avoided. Routing can help here.
If we can the "Plan Mode" by Cursor is an excellent example of use case where planning can be useful.

## Chapter 7: Multi-Agent 

This is a very active area of research. A lot has been experimented since this book was published. The chapter reads very thin and misses a lot of what the community has found out about multi-agent systems since this book was published.
Particularly noteworthy experiments by Cursor https://cursor.com/blog/self-driving-codebases on .

Also useful https://ai.pydantic.dev/multi-agent-applications/.
Keywords for further research: agent swarms

# Part Two

## Chapter 8: Memory Management
Very relevant topic. Here the style of the different agentic frameworks actually varies a bit.
Some concepts would be implemented Pydantic AI via https://ai.pydantic.dev/dependencies/, which is a more general concept than memory management, but can be used for that as well.

## Chapter 9: Learning and Adaptation

This seems overhyped and not especially useful in practice for production use.

## Chapter 10: Model Context Protocol (MCP)
The section discussing the difference between tool use and MCP is not very clear. On a conceptual level, MCP is just a more structured way to implement tool use. The main difference is that MCP defines a specific protocol for how the agent should interact with the tools, while tool use can be implemented in a more ad-hoc way.

In practice, the conceptual difference between the two  is not very important. Especially, if you use agentic coding.

Interesting developments in this area since this book was published:
- https://pydantic.dev/articles/pydantic-monty
- https://blog.cloudflare.com/code-mode/
- https://www.anthropic.com/engineering/code-execution-with-mcp

## 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.

Interesting developments in this area since this book was published:
- https://github.com/karpathy/autoresearch takes this to another level by using a self-driving codebase to automatically conduct research in the field of deep learning. The agent is able to set its own goals, monitor its progress, and adapt its strategy as needed to achieve its objectives.

# Part Three
## Chapter 12: Exception Handling and Recovery 

## Chapter 13: Human-in-the-Loop 

## Chapter 14: Knowledge Retrieval (RAG) 

# Part Four

## Chapter 15: Inter-Agent Communication (A2A)
Advertising for Google's Agent2Agent protocol, which has not seen much adoption. MCP protocol can be used for inter-agent communication as well, and it is more widely adopted. Skip this chapter.

## Chapter 16: Resource-Aware Optimization 

## Chapter 17: Reasoning Techniques 

## Chapter 18: Guardrails/Safety Patterns 

## Chapter 19: Evaluation and Monitoring 

## Chapter 20: Prioritization 

## Chapter 21: Exploration and Discovery

# Conclusion
- Some high-level concepts are still relevant.
- Sections promoting Google products like the Agent2Agent protocol and Gemini ADK can safely be skipped. The author's bias is fairly clear here, given that they work at Google.
- The text descriptions are enough to understand the concepts. I personally like the Pydantic AI agent framework more than the ones used in the book (LangChain, Google ADK, Agent Crew). Overall, the code examples are not very useful and, in some cases, even distracting.