An agent is best understood not as a new kind of magic, but as a system of state, tools, planning, and checks.
The chapter shows where an agentic approach truly pays off and where it only adds orchestration, unpredictability, and operational risk.
For interviews and architecture discussions, it helps move the conversation away from the idea of a "fashionable agent" and toward autonomy boundaries, tool use, failure handling, and the cost of added complexity.
Practical value of this chapter
Agent loop
The book breaks an agent system into state, planning, tools, and checks so you can discuss it as architecture rather than as magic.
Memory and tools
It is a strong guide for explaining why agents need memory, how access to external systems works, and why these layers often break first.
Cost of autonomy
It helps you discuss the trade-offs of autonomy honestly: extra orchestration, cost, unpredictability, and stronger observability requirements.
Interview material
It gives you a clear frame for discussing memory, tool use, planning, multi-agent setups, and safe degradation.
Primary source
O'Reilly Learning
Early Release page for An Illustrated Guide to AI Agents
An Illustrated Guide to AI Agents
Authors: Jay Alammar, Maarten Grootendorst
Publisher: O'Reilly Media, Inc. (Early Release)
Length: Early Release (в процессе написания)
Jay Alammar and Maarten Grootendorst: a practical visual guide to agent systems covering memory, tools, planning, self-checking, multi-agent coordination, and engineering risks.
Why this is the right follow-up to Hands-On LLM
If Hands-On Large Language Models explains how the model itself works, this book explains how to build a working agentic system around it.
Step 1: understand how the LLM works
Transformer internals, tokens, embeddings, inference behavior, and the model's core limitations.
Step 2: design the agentic application
Memory, tools, planning, self-checking, and multi-agent coordination as a distinct engineering problem.
Related chapter
AI Engineering
Live-system practices for AI systems: evaluation, RAG, agents, and fine-tuning
What is already available in the book
The book is in Early Release and already covers the core of agent architecture. The published chapters are already enough to build a coherent engineering picture, from memory and tools to planning and multi-agent coordination.
Introduction
Why an agentic approach matters and where a one-off LLM call stops being enough.
Chapter components:
- What should count as an agentic system: the difference between a one-shot LLM call and a loop of planning, acting, and checking.
- Core components: model, state, orchestrator, tool layer, and observability.
- Where a chatbot is no longer enough: multi-step work, API integrations, and longer user-facing processes that will not fit into a single answer.
- How to judge whether the architecture worked: reliability, controllability, latency, cost, and reproducibility.
Reasoning LLMs
What changes when a model can reason during inference, and how that affects the surrounding architecture.
Chapter components:
- The difference between a fluent answer and genuine reasoning behavior on harder tasks.
- Deeper reasoning during inference lifts quality, but you pay for it in response time and per-call cost.
- When a reasoning-heavy model is worth it, and when plain generation is enough — the extra steps only add cost.
- How to control reasoning quality through step checks, fallback paths, and compute limits.
Memory
Short-term versus long-term memory, context engineering, and state management between agent steps.
Chapter components:
- What belongs in the context window and what should move into external state before the window becomes the bottleneck.
- Long-term memory: how to store facts, preferences, and execution artifacts between steps.
- Retrieval policies: relevance, TTL, summarization, deduplication, and context hygiene.
- Memory risks: sensitive-data leakage, context drift, and quality loss as state grows.
Tool Usage, Learning, and Protocols
Tool use, external integrations, and interaction protocols, including MCP.
Chapter components:
- Tool contracts: argument schemas, validation, typing, and the responsibility boundaries an agent must not cross.
- The tool execution cycle: selecting an action, handling errors, retry behavior, and post-processing.
- Connecting external systems through MCP and related approaches — and where each option carries its own architectural price.
- Moving from text generation to real-world actions immediately raises the bar for safety and auditability: a mistake now changes the state of the world, not just the text.
Planning and Reflection
Task decomposition, plan revision, and self-checking as a separate quality layer.
Chapter components:
- Decomposing a complex goal into executable sub-tasks and a staged plan of steps.
- When a plan has to be rebuilt: new data arrives, a tool fails, or priorities change.
- How reflection and self-checking loops raise quality and cut out obvious mistakes.
- Budget, timeout, and loop-depth limits: without them self-checking quietly grows more expensive than the task itself.
Multi-Agent Systems
Role separation, multi-agent coordination, and the price of added architectural complexity, including A2A scenarios.
Chapter components:
- Role patterns: planner, researcher, executor, reviewer, and handoff rules between them.
- Coordination topologies: a central coordinator, peer-to-peer collaboration, and hierarchical supervision.
- State alignment across agents: shared context, messaging protocols, and conflict handling.
- Key risks: cascading failures, difficult traceability, and higher infrastructure cost.
Where engineering risks show up
Memory and context management
Without an explicit strategy for storing and refreshing state, relevance drops quickly: latency grows, context drifts, and token costs become unpredictable.
Tools and safe integrations
Once tools are connected, the system moves from text generation to action execution. Mistakes in permissions, validation, or retry logic become risks for a live system.
Planning depth vs cost
Self-checking loops improve output quality, but every pass is extra model calls. Without hard limits on budget, timeouts, and planning depth, quality starts to cost unpredictably much.
Coordination of multiple agents
Multiple agents help separate responsibilities, but in return they make observability, error tracing, and consistency control harder. You pay for that separation with system transparency.
Who should read it and how
Best fit for
- Engineers and tech leads who design AI features as product systems rather than one-off demos.
- Teams that need a practical engineering picture of memory, tools, planning, and orchestration.
- Readers who already understand LLM fundamentals and want to move into agent and multi-agent architecture.
Suggested order
- Start with Hands-On Large Language Models to lock in the LLM foundation.
- Then read An Illustrated Guide to AI Agents as the architectural layer around the model.
- After that, reinforce live-system practices with AI Engineering and Prompt Engineering for LLMs.
What to study in parallel
In the tool-usage and multi-agent sections, it is useful to compare MCP and A2A directly, because protocol choice affects responsibility boundaries, observability, and overall system resilience.
Related chapters
- Hands-On Large Language Models - Builds the LLM foundation that later supports memory, planning, and tool use in agent systems.
- AI Engineering - Shows how to bring agent patterns into live systems through evaluation, RAG, observability, and operational reliability.
- Prompt Engineering for LLMs - Deepens prompt and workflow design patterns that later grow into planning logic and tool-calling loops.
- Developing Apps with GPT-4 and ChatGPT - Shows practical LLM application patterns that make a natural bridge toward fuller agent architectures.
- AI in SDLC: the path from assistants to agents by Alexander Polomodov - Provides a real-world transition story from assistants to agents and the engineering trade-offs teams face on that path.