How to use this book

Who this book is for

Agent Engineer (AGE) is the Black Belt, 1st Dan course. It assesses whether you can design long-running, multi-step agents and operate them with tools, memory, evaluation and observability in place, keeping failures and costs under control. Its two main audiences are engineers who design and operate agent systems, and leads of AI platform teams supporting several agent products.

The recommended background is Red Belt (LLM API Developer) level API skills and at least six months of experience operating agents. The book assumes you understand message structure, the basic tool-calling flow and the relationship between tokens and cost. However, terms introduced in this book are explained when they first appear, and each difficult concept comes with an everyday analogy. Even with a little less experience, you can follow along by reading the chapters in order.

Model pre-training is outside the scope. This book is concerned with the structure around an existing model, the tools and memory it receives, how to evaluate the system and where to halt execution. Framework and product names keep changing, but these design judgments remain useful.

How this book is organized

The five chapters correspond directly to the five exam domains. Chapter 1 covers choosing a structure; Chapter 2, connecting to the outside world through tools and MCP; Chapter 3, preserving memory and state during long tasks; Chapter 4, measuring quality and locating failures; and Chapter 5, combining cost, failure and risk into operating policy. Decisions in earlier chapters lead into problems in later ones, but each chapter can also be read independently.

Every chapter has the same ten sections.

Section Purpose
Learning objectives What you should be able to do after completing the chapter
Introduction A short story showing why the chapter matters, and a map of its contents
Key concepts Full coverage of the knowledge and skills in the exam scope
Going deeper Trade-offs, boundary cases and failure analysis
At work How fictional organizations move from a problem to a decision, including rejected alternatives
Common mistakes Plausible but incorrect ideas and why they fail
Summary at a glance A summary to revisit the day before the exam
Check the official docs Official pages for checking details
Self-check Questions for checking your understanding; explanations are in Appendix B
Hands-on tasks Practical tasks taking 30–60 minutes

Appendix A is the glossary, Appendix B explains the self-check answers, Appendix C offers exam day guidance, and Appendix D lists the official documents cited in this book.

The exam at a glance

Type Questions Time Criterion
Dan exam 40 questions 70 minutes Pass with a raw score of 75 or more
Free practice set 10 questions 25 minutes Only the score is provided
Chapter Domain Weight
Chapter 1 Agent architecture 20%
Chapter 2 Tools and MCP 20%
Chapter 3 Context, memory and state 20%
Chapter 4 Evaluation and observability 20%
Chapter 5 Operations, cost and safety 20%

The exam assesses five abilities: choosing a workflow or agent structure suited to the task; designing tools and MCP servers within safe permission boundaries; managing context, memory and state for long-running work; catching quality regressions through evaluation and observability; and turning failure handling, cost control and human approval points into operating policy. All five domains carry equal weight, so weakness in any single domain makes the passing score harder to reach.

What the questions look like

The paper resembles Korea's CSAT (Suneung) exam paper. Every question is answered by choosing one number from ① to ⑤. There are five question formats, presented on the paper as follows.

Format Appearance on the paper
Single choice One of five options
Multiple choice Options appear in a <Statements> box labeled A, B, C…; each numbered answer is a combination containing the stated number of options
Statement judgment Statements appear in a <Statements> box; each numbered answer combines the statements judged correct. Both the judgment and its reason must be correct for a statement to count as correct
Ordering Steps (A)–(E), with five candidate sequences
Matching Five candidate sets pairing items on the left with targets on the right; one right-hand target is left over

Points reflect cognitive demand. Questions testing recognition of a concept or application of a single principle are worth 2 points; analytical questions weighing two or more constraints are worth 3. Most questions in this course are analytical. The organization, data scale and objectives are specified, and changing one condition shown in bold is designed to change the correct answer. Choosing by keywords alone can therefore lead to a wrong answer. This is also why the work scenarios in this book always include rejected alternatives. The raw score is points earned divided by total available points, converted to a score out of 100. Grades use a fixed nine-grade scale, with boundaries at 90, 80, 70, 60, 50, 40, 30 and 20 points.

Six-week study plan

The plan assumes one hour a day, five days a week. You can complete the hands-on tasks in one batch over the weekend.

Week Reading Hands-on work
Week 1 How to use this book, Chapter 1 Redraw one feature in operation as patterns and compare it with a simpler structure
Week 2 Chapter 2 Redesign and measure a frequently misused tool; write a permission table
Week 3 Chapter 3 Add a progress file and checkpoints; force an interruption and test resumption
Week 4 Chapter 4 Build an evaluation set from 20 real failures and use traces to locate the failing stages
Week 5 Chapter 5 Put a risk table, stopping conditions and approval points on the execution path and test them
Week 6 Appendices and full review Repeat the self-checks, take the free practice set and organize review notes

On the last day of each week, explain the points in that chapter's “Summary at a glance” aloud. Any line you struggle to explain is something to reread the next week.

Key point

The self-checks were written separately to avoid overlap with exam questions. Rather than memorize their answers, apply the principles behind Appendix B's explanations to unfamiliar situations. The exam tests your ability to apply principles to combinations of constraints you have not seen before.

Notation and sources

Vendor-specific facts in this book—feature names, parameters, defaults and limits—were checked against the respective official documentation on October 20, 2026. Sources include Anthropic engineering articles and developer documentation, the Model Context Protocol (MCP) specification, OpenAI Agents SDK documentation and OpenAI guides, Google Agent Development Kit (ADK) documentation, and official OWASP, NIST and AWS materials. For MCP, the book follows the 2026-07-28 specification, the latest revision on the verification date. Differences from earlier revisions are identified where relevant.

The book follows these conventions.

  1. Product, API and parameter names retain their original spelling (max_turns, isError, tools/list).
  2. Material that cannot be verified in vendor documentation is described only as a general principle, rather than as a particular vendor's feature.
  3. Model version numbers and prices appear only when essential to a decision. Usually, the book directs you to the official documentation, because these values change frequently.
  4. All organizations, people and figures in the scenarios are invented. They are unrelated to real companies or customers.
  5. Normative terms in framework documentation, such as MUST and SHOULD, are expressed as requirements and recommendations respectively, with the original term in parentheses where needed.

Vendor documentation changes faster than this book. If the two disagree while you study, follow the documentation. Each chapter's official documentation section and Appendix D are the starting points for checking.