Agentic Design Patterns: From Prompt Chains to Agent Systems (Category #Books)

I finished Antonio Gulli's Agentic Design Patterns. I picked it up as a reference on agent architecture, but what I appreciated most was its progression. The book presents not a collection of fashionable frameworks, but a ladder of complexity—from one controlled model call to a system in which several agents plan, use tools, retain state, and check one another.

The book contains 21 patterns, which I would group into five levels.

1️⃣ Flow control: prompt chaining, routing, and parallelization

The model does not yet have much autonomy. We explicitly decide how to split the task, where to route a request, and what can run in parallel. This is already useful in AI4SDLC: requirements, code, tests, and risks can be analyzed separately and then combined into one result.

2️⃣ Agency: reflection, tool use, and planning The system gains a feedback loop. It can reconsider an output, invoke an external action, and break a goal into steps. This is where an ordinary chain first starts to resemble an agent.

3️⃣ State and coordination: multiple agents, memory, learning and adaptation, MCP, goal setting, and monitoring Complexity moves out of the prompt and into the architecture: who owns what, which context moves forward, where state is stored, and how the system determines that the shared task is actually complete.

4️⃣ Working with reality: error recovery, human-in-the-loop, and RAG The agent system stops being a polished demo and encounters incomplete data, failures, and decisions that cannot be delegated to a model without supervision.

5️⃣ Operating at scale: A2A communication, resource management, reasoning techniques, guardrails, evals and monitoring, prioritization, exploration, and search for alternatives At this level, the main question is no longer “can the agent complete the task?” It is “can we observe the work, bound its cost and blast radius, and stop the system in time?”

The examples are painted on several different “canvases”: LangChain and LangGraph, CrewAI, and Google ADK. That is a good choice. It makes clear that a pattern is an architectural decision, while a framework is only one way to express it.

The code now comes with a caveat. The book was published in 2025, and agent frameworks can change their APIs, abstractions, and recommended practices within a few months. Some examples will need repairs. I would treat them as executable diagrams rather than production-ready boilerplate.

There is another paradox: many chapters already seem almost obvious. Almost everyone now knows about tool use, memory, routing, planner/evaluator designs, human-in-the-loop, MCP, guardrails, and evals. That does not make the book obsolete. The industry has simply caught up with its vocabulary very quickly. Many teams are already building multi-agent systems of their own—and rediscovering the same questions about state, ownership, verification, observability, and cost.

My main takeaway is that we should not start with a team of agents. Start with the smallest controllable loop: a clear task, a bounded tool set, a stop condition, and independent verification of the result. Add memory, roles, and parallelism only when the simple design has genuinely become the bottleneck. Every new pattern buys the system a capability, but also introduces a new class of failure.

I would recommend the book to engineers, architects, and technical leaders who need a shared map of agent systems. If you need a current tutorial for a particular version of LangGraph or ADK, go straight to the documentation. As a language for discussing agent architecture, however, the book remains very useful.

P.S. I read most of the book while traveling, so it was a little worse for wear by the time I finished it.

#Books #AI4SDLC #AI #Agents #Architecture #Engineering