Patterns for Building AI Agents (SAM BHAGWATMICHELLE GIENOW)（Z-Library）

【One-Line Pitch】 A pragmatic field guide to shipping AI agents, drawn from the hard-won lessons of teams already running them in production. Read this if you've moved past "what should an agent do?" and are now wrestling with architecture, context, evaluation, and security. 【Book Arc】 - **Opening (~0%–9%)**: Frames the book's purpose — moving from the conceptual "what to build" of *Principles* to the pragmatic "how to build" of *Patterns*, and previews the four-part structure: agent design, context engineering, evals, and security. - **Early (~9%–30%)**: Part I, "Configure Your Agents." Covers turning a wishlist of capabilities into a coherent architecture: whiteboarding capabilities, evolving from monolithic mega-agents to grouped specialists, dynamic runtime configuration, and human-in-the-loop review. - **Middle (~30%–43%)**: Part II, "Engineer Agent Context." Tackles the Goldilocks problem of context — parallelizing carefully, sharing context between subagents, avoiding failure modes, compressing context, and feeding errors back into the loop. - **Late (~43%–52%)**: Part III, "Evaluate Agent Responses." Shifts from building to measuring: listing failure modes, defining critical business metrics, cross-referencing the two, and iterating against evals with SME-labeled and production datasets. - **Ending (~52%+)**: The excerpts trail off mid-Part III; the introduction also promises a final section on agent security, but the excerpts do not cover its contents. 【Key Takeaways】 - **Architecture emerges through iteration, not upfront design** (Early): The book's running example shows a content agent evolving across five iterations from a single writer into a coordinator → router → specialist chain. The lesson is to solve one problem at a time rather than build a "master agent." - **Monolithic mega-agents fail predictably** (Early): The more tools an agent has, the higher the odds it picks the wrong one. Grouping capabilities by department, task type, or business process keeps each agent focused and reliable. - **Dynamic agents trade simplicity for customization** (Early): Runtime signals like user tier, preferences, or system state can drive tool selection, memory, and model choice — but this introduces complexity in logic, testing, and consistency. - **Full autonomy is often untenable; design for human fallback** (Early): Heterogeneous agent performance and legal/ethical stakes mean humans should review risky or low-confidence outputs. Patterns include post-processing review, in-the-loop confirmation, and deferred tool execution. - **Context engineering is both art and science** (Middle): It draws on prompt engineering, RAG, tool calling, and agent state, but also on intuition about how LLMs behave. Too little context starves the agent; too much derails it. - **Parallel subagents create incompatible outputs** (Middle): When subagents work in isolation, they can produce conflicting intermediate results. Solutions include single-threaded linear threads, sequential execution, or sharing full traces between agents. - **Compression and error feedback keep long-running agents coherent** (Middle): Periodic context compression (at thresholds, at tool-call boundaries, or via recursive summarization) prunes irrelevant tokens, while feeding error messages back into context lets agents self-correct instead of crashing. - **Evals are the discipline that turns an MVP into a production agent** (Late): Because LLM outputs are nondeterministic, teams must classify failure modes, define business-aligned success metrics, cross-reference the two, and iterate with SME-labeled and production datasets. 【Reading Tips】 - **Deep-read Part I if you're starting a new agent.** The whiteboarding and architecture-evolution patterns are the most immediately actionable and require no prior infrastructure. - **Treat Part II as a reference during debugging.** Context failure modes, compression strategies, and error-feedback patterns are best consulted when you hit specific reliability problems, not read cover-to-cover. - **Don't skip Part III even if you're an engineer.** The eval workflow (SME labeling → PM prioritization → engineering iteration → validation) is the book's bridge between technical metrics and business outcomes. - **Watch for the running examples.** The content-agent iterations and the medical claim review agent carry the most concrete lessons; the excerpts are thin on other case studies. - **Note the disagreements.** The book flags that not everyone agrees on context-sharing approaches (e.g., Devin vs. Claude Code), so treat patterns as options, not dogma. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book (through Part III's eval workflow). The promised security section and the remainder of Part III are not represented in the excerpts, so their specific patterns are not summarized here.