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.