06. Module 09 Review — Agents & Tool Calling

Focus: loop mechanics, tool schemas, error handling, stopping rules, and state across turns.

Review loop

1. Skim the TOC in 02_explainer.md. Re-read any chapter that still feels slippery.
2. Re-answer the self-check questions in 01_weekly_plan.md without notes.
3. Re-do the hardest prompts in 04_daily_recall.md from memory.
4. Sketch the failure-fix table from explainer §6.1.
5. Review 05_hands_on_lab.md and record:
6. one tool design choice you would keep
7. one guardrail you missed initially
8. one failure trace you would now debug faster
9. Open module 10's 01_weekly_plan.md only after finishing the audit below.

Reflection

• Where does your mental model of "tool use vs agent" still feel fuzzy?
• Which guardrail now feels obviously non-negotiable?
• What part of state management still feels hand-wavy?
• What should feel automatic before Module 10?

Embedded checkpoint

This module is the foundation checkpoint for the next phase. If this is weak, module 10 will feel harder than necessary.

Conceptual

1. Why is one correct tool call not enough for a multi-step task?
2. ReAct — what are the three steps, and why does observation matter?
3. Why do narrow tools usually beat one mega-tool?
4. What should a good tool description contain?
5. Structured error vs raw exception — why does the difference matter?
6. What is idempotency, and why do agents care?
7. Stop rule vs give-up rule — difference?
8. When should a human-in-the-loop gate appear?
9. Parallel tool calls — when do they help, and when are they unsafe?
10. Messages vs structured state vs memory — how do they differ?

Applied

1. Design a support agent for refund requests. What tools, what guardrails, what eval cases?
2. Your agent keeps choosing search_kb instead of lookup_account. What three fixes would you try first?
3. A tool sometimes times out. How would you represent the error, retry safely, and stop loop storms?
4. A PM asks, "Can we just add more tools?" Explain when that helps, and when it makes routing worse.
5. Before module 10, what exact pieces of state would you carry across turns?

Foundation-gap audit for module 10

Mark each without notes.

• [ ] I can explain a single-agent loop clearly.
• [ ] I can design a tool schema with a precise description.
• [ ] I can explain validation, retryable errors, and terminal errors.
• [ ] I can define both stop rules and give-up rules.
• [ ] I can separate messages, structured state, and memory.

If any box remains unchecked, re-read explainer §2-§5 before moving on.

Self-evaluation

Section	Score	/
Conceptual	__	20
Applied	__	10
Foundation audit	__	5
Total	__	35

Completion gate

• [ ] All explainer chapters read
• [ ] Failure-fix table recreated from memory
• [ ] Weekly plan completed
• [ ] Assignment shipped
• [ ] Foundation-gap audit passed
• [ ] Ready to move to Module 10