Title here
Summary here
Module · 5 lessons
Designing Tools
Make tools Claude uses well and that fail safely — clear schemas, Pydantic validation, an error-and-repair loop, and the patterns that keep tool use reliable.
At a glance
Level
Intermediate
Lessons
5 lessons
Time to complete
1 week
Cost
Free forever · no sign-up
Welcome to Designing Tools, the third module. You can already build the agent loop — but a loop is only as good as the tools you give it. In practice, most of an agent’s reliability comes down to tool design: whether Claude reaches for the right tool, fills in the arguments correctly, and recovers when something goes wrong. This module is about getting that right.
You’ll learn what makes a tool Claude uses well — names, descriptions, and schemas that guide the model toward correct calls. You’ll validate inputs with Pydantic, so a wrong argument is caught before it reaches your code (and you’ll generate the tool’s schema straight from the model). You’ll build the error-and-repair loop, where a failed call comes back to Claude as a tool_result it can learn from and fix on the next step. And you’ll cover the design patterns — tool granularity, parallel calls, side effects, and clear return values — that keep tool use dependable. The module ends by rebuilding Atlas’s tools to be genuinely robust.
Every mechanism here — Pydantic validation, schema generation, the repair loop — is real, runnable Python, verified end to end. Start with Lesson 1 on what makes a good tool.
Lessons in this module
1
What Makes a Good Tool
Design tools Claude reliably picks and calls correctly — clear verb-noun names, descriptions that say when to use them, tight input schemas, and clear return values.
2
Validating Inputs with Pydantic
Catch bad tool inputs before they reach your code — define inputs as a Pydantic model, generate the tool schema from it, and validate every argument Claude sends.
3
Errors and the Repair Loop
Turn tool failures into self-correction — return validation and runtime errors as is_error tool_results so Claude can read what went wrong and retry with a fixed call.
4
Tool Design Patterns
The judgment calls behind a dependable tool set — right-sizing tool granularity, running tools in parallel safely, gating side effects, and shaping clear return values.
5
Guided Project: Robust Atlas Tools
Rebuild Atlas's tools to be robust — Pydantic input models, schemas generated from them, a validate-then-run wrapper, and a loop that turns failures into self-correction.
Achievement
Complete all 5 lessons to finish the Designing Tools module.