First, Build a Shared Language

Xiao A's first day on the job: his boss handed him a task list full of unfamiliar words — token, tool call, session, compaction, MCP, RAG. He read through the company's documentation. Every word seemed familiar, yet he could not pin down any of them precisely. Worse, different products use these words differently.

He took his laptop and went to Lao Z. "These concepts — can I just copy someone else's code and understand them that way?"

Lao Z shook his head. "Copying code teaches you only that 'someone wrote it this way'. It does not teach you why they wrote it that way. If the concepts are not standing firm before you enter real engineering, you will mix directory names, product habits, and general mechanisms into one pile. We have to build a shared language first."

Xiao A opened his notebook. "So what does this language cover?"

"Answer one question first," Lao Z said. "When you get a new Agent-related project, you usually want to know four things: what model it uses, how it breaks a task into actions, how it keeps those actions looping, and how it prevents things from running out of control. Part I · Concepts follows those four questions and goes from the model all the way to the boundary."

What this part solves

After reading Part I · Concepts, you can tell apart model generation, tool execution, state loops, external capability integration, material retrieval, orchestration, and safety boundaries. You can also judge what a design discussion is missing: a model constraint, a tool contract, state control, or a safety boundary.

This part does not explain any product's directories, interfaces, or implementation choices, and it does not claim that one general architecture can cover every task.

"Are these concepts taught in some order?" Xiao A asked.

"Yes, and that order is the order you should read." Lao Z drew a line on a piece of paper. "The concepts move step by step from how a model produces output, to how actions stay under control, to how materials enter the context, and finally to how the system limits the worst-case damage. Those dependencies unfold naturally between neighbouring chapters."

"Can you be more concrete?" Xiao A pressed.

"Split it into three sections," Lao Z said. "The first is about LLMs: what a model is, how to choose one, how to connect to one, and how to lay down rules for it. The second is the Agent itself: the thing that assembles the model, the tools, and the loop — its definition and how it works. The third is Agent engineering: tools, loops, memory, extensions, multiple executors, retrieval, orchestration, and finally safety guardrails. Each section is built on ground the previous one cleared."

The three sections of Part I · Concepts

• LLM topics (Chapters 1–6): the model is a component, not an oracle; selection is settled by evaluation, not by parameter counts; the generation mechanism, thinking budget, Provider abstraction, System Prompt, and Function Calling
• The Agent itself (Chapter 7): a machine that relays automatically — the model proposes, the host approves, the loop drives
• Agent engineering (Chapters 8–17): Tool, Agent Loop, memory, Hook, MCP, Skill, multi-Agent, RAG, Workflow, and security

"Are these three sections specific to Part I · Concepts, or do they belong to the whole book?" Xiao A asked.

"They are specific to Part I · Concepts, but they line up with the whole book," Lao Z said. "Part I · Concepts talks about boundaries. Part II · Pi in Source talks about landing them. Part III · Build It talks about the trade-offs. The three parts are the same object at three depths. The three sections of Part I · Concepts map to the responsibility split across the eight packages in Part II · Pi in Source, and to the assembly order of the minimal artifact in Part III · Build It. Only the granularity differs from part to part."

"Why is Agent Chapter 7 instead of the first chapter?" Xiao A asked.

"Because without the model, the prompt, and function calls settled first, you cannot describe an Agent accurately," Lao Z said. "Everything before Chapter 7 is a part. Chapter 7 is about assembling those parts into one machine. What comes after is about engineering that machine in a real environment. Read this order backwards and you will get stuck everywhere."

Xiao A was about to leave when Lao Z called him back: "One more reading discipline. Remember it first:"

How to read this part

• Keep illustrations and facts apart: protocol and security conclusions come with links to the original sources
• State the scope of applicability for every engineering recommendation; do not treat it as universally true
• Leave all product behaviour to Part II · Pi in Source for verification — Part I · Concepts names no specific product

"What does that last line mean?" Xiao A asked.

"It means this: Part I · Concepts answers only 'how does this kind of thing usually work'. It does not answer 'how does product X implement it specifically'," Lao Z said. "Take tools, for example. Part I · Concepts says a tool should have a description, a schema, and an execution boundary. What one particular product's tool registry actually looks like is Part II · Pi in Source's job."

"And how do I judge 'keep illustrations and facts apart'?" Xiao A asked.

"Look at whether the claim can be checked," Lao Z said. "A fact is 'this mechanism is defined this way in some specification'. An illustration is 'assume a typical scenario runs like this'. In this book, every flow diagram, piece of pseudocode, and simplified sequence of steps is labelled 'illustration' or 'simplified'. They are tools for understanding, not specifications you can cite."

"What is the Hands-on Verification at the end of each chapter for?" Xiao A asked.

"To make the concepts your own," Lao Z said. "Every chapter of Part I · Concepts ends with a Hands-on Verification. It is not a quiz. It asks you to do the thing once with your own hands: run two models and compare their outputs, write a schema for a tool, let a loop run out its budget. Read it and skip the doing, and you might as well not have read it."

"One last map, so you know your way around." Lao Z spread out the full map of Part I · Concepts:

The 17-chapter roadmap of Part I · Concepts

LLM topics

• Chapter 1: The Model Is a Component — The Role of the LLM and Choosing One
• Chapter 2: The Truth About the Next-Token Machine — LLM
• Chapter 3: Leaving a Scratch Paper for Thinking — CoT
• Chapter 4: How the Translation Bureau Connects to Models — Provider
• Chapter 5: Set the Rules Clearly First — System Prompt
• Chapter 6: From "Saying" to "Doing" — Function Calling

The Agent itself

• Chapter 7: A Machine That Relays Automatically — Agent

Agent engineering

• Chapter 8: Fitting Handles onto Capabilities — Tool
• Chapter 9: Getting the Work to Actually Loop — Agent Loop
• Chapter 10: What to Remember, What to Forget — Memory
• Chapter 11: A Word Before the Action — Hooks
• Chapter 12: Leaving a Door for External Tools — MCP
• Chapter 13: Putting Experience into an Instruction Manual — Skill
• Chapter 14: Work Alone or Work in a Group — Multi-Agent
• Chapter 15: Let the Model Answer with Its Materials in Hand — RAG
• Chapter 16: When There Is More Than One Route — Workflow & Graph
• Chapter 17: Fitting Guardrails onto Autonomy — Security

"I'd guess Chapters 1–9 have to be read in sequence, and after that I can pick and choose?"

"That direction is right," Lao Z said. "Chapters 1–9 are one continuous spine: model, prompt, function calling, Agent, tool, loop. Miss one chapter and the later mechanisms will not connect. Chapters 10–16 are relatively independent extension surfaces. Each chapter covers one mechanism, so pick them by how relevant they are to your work. Chapter 17, the safety boundary, is required reading. Read it last: it gathers every mechanism before it into one guardrail."

"How long does each chapter take?"

"Thirty minutes to an hour for the text, and double that if you do the Hands-on Verification," Lao Z said. "The Hands-on Verification is the most time-consuming and the most valuable part of Part I · Concepts. It turns 'I followed that' into 'I checked it'. If time is tight, rather read two chapters fewer than skip the verification and keep turning pages."

"When I finish Part I · Concepts, roughly what level am I at?" Xiao A asked.

"At the level of 'you can follow a design discussion, but you still cannot build it'," Lao Z said. "At the end of Part I · Concepts, you can point at an Agent architecture and say clearly what the model owns, what the tools own, what the loop owns, and what safety owns. But you still do not know how a real project organizes them together. That is exactly where the next part starts: take these concepts into the real source of pi-mono and see how these boundaries land in engineering."

"Got it." Xiao A returned to his desk and opened the first page. On it was one question: why can a piece of text generated by a model sometimes become one controlled engineering action?

Start here: Chapter 1: The Model Is a Component — The Role of the LLM and Choosing One