How much does zuzu.codes cost?

The starter track is free — read all lessons and practice for free. Full access to every track (current and future) is $14.99/month. Cancel anytime.

How long does each track take?

Each track is designed as a 30-day challenge — one lesson per day, about 15 minutes each. Go at your own pace, but the structure is built around daily consistency.

What's the lesson format?

Each lesson is a student-teacher dialogue with code examples, followed by a hands-on code challenge in an in-browser editor. You read, you understand, then you write real code.

Do I need prior coding experience?

Our beginner track starts from absolute zero — no prior experience needed. Advanced tracks build on earlier ones, and the platform tells you exactly where to start.

How is zuzu.codes different from freeCodeCamp or Codecademy?

zuzu.codes uses a structured 30-day track format with dialogue-based teaching, an in-browser code editor, and gamification (XP, streaks, progress tracking). The format builds genuine understanding through daily practice.

Privacy Terms

Day 17 · ~12 min●

Yesterday's pseudocode in real code. Pydantic-AI's Agent wraps the loop for you — your job is to register tools and pass an iteration cap.

python

from pydantic_ai import Agent
agent = Agent(model)

@agent.tool_plain
def add(a: int, b: int) -> int:
    """Return the sum of two integers."""
    return a + b

@agent.tool_plain
def multiply(a: int, b: int) -> int:
    """Return the product of two integers."""
    return a * b

result = agent.run_sync(
    "Compute 2 + 3, then multiply that by 4. Use the tools step by step.",
)
print(result.output)         # contains "20"
print("messages:", len(result.all_messages()))

This looks the same as L4 (multi-step tool calls). What's new?

The mental shift. L4 framed it as "two tool calls in one prompt". L17 frames it as "an agent loop ran two iterations". result.all_messages() lets you inspect each iteration — the user prompt, each tool call, each tool result, the final answer. Same code, deeper visibility.

Where does the iteration cap live?

Pydantic-AI sets a default max (around 10). For a real agent you'd configure it explicitly via usage_limits. Today's task only needs 2 iterations, so the default is fine. Tomorrow we'll add a third tool and watch the model pick among them — that's where loop visibility starts paying off.

Agent loop with pydantic-AI

python

agent = Agent(model)

@agent.tool_plain
def tool_a(...): ...
@agent.tool_plain
def tool_b(...): ...

result = agent.run_sync(prompt)
# pydantic-AI ran the loop until the model emitted a final answer

The library handles:

Sending the prompt + tool schemas
Reading each model response
Detecting tool-call requests and executing them
Feeding tool results back as the next user message
Stopping when the model emits a final answer (or hits the iteration cap)

Inspecting the loop

python

for msg in result.all_messages():
    # each msg has parts: text, tool calls, tool returns
    print(type(msg).__name__)

Message types you'll see:

ModelRequest — what was sent (your prompt + previous tool results)
ModelResponse — what came back (tool call requests OR final text)

For a 2-iteration loop on "2 + 3 then * 4":

Request: "compute 2+3 then multiply by 4"
Response: tool call add(2, 3)
Request: tool result 5
Response: tool call multiply(5, 4)
Request: tool result 20
Response: final text "The answer is 20."

Three LLM calls under the hood. Two tool calls. One run_sync from your perspective.

Configuring iteration limits

python

from pydantic_ai.usage import UsageLimits
limits = UsageLimits(request_limit=10)
result = agent.run_sync(prompt, usage_limits=limits)

For lessons we accept the defaults. For production you'd set explicit caps.

When the agent fails to terminate

If the model calls tools forever (rare but possible with confused tasks), pydantic-AI raises after the iteration cap. Catch it; log; pick a safer prompt or smaller toolset. The loop will terminate one way or another — by completion or by cap.

Today's task

"Compute 2 + 3, then multiply that by 4." Two tools. Final answer 20. Verification asserts "20" in the output.

Sign up to practice

Create a free account to get started. Paid plans unlock all tracks.

or

Day 17 · ~12 min●

Yesterday's pseudocode in real code. Pydantic-AI's Agent wraps the loop for you — your job is to register tools and pass an iteration cap.

python

from pydantic_ai import Agent
agent = Agent(model)

@agent.tool_plain
def add(a: int, b: int) -> int:
    """Return the sum of two integers."""
    return a + b

@agent.tool_plain
def multiply(a: int, b: int) -> int:
    """Return the product of two integers."""
    return a * b

result = agent.run_sync(
    "Compute 2 + 3, then multiply that by 4. Use the tools step by step.",
)
print(result.output)         # contains "20"
print("messages:", len(result.all_messages()))

This looks the same as L4 (multi-step tool calls). What's new?

The mental shift. L4 framed it as "two tool calls in one prompt". L17 frames it as "an agent loop ran two iterations". result.all_messages() lets you inspect each iteration — the user prompt, each tool call, each tool result, the final answer. Same code, deeper visibility.

Where does the iteration cap live?

Pydantic-AI sets a default max (around 10). For a real agent you'd configure it explicitly via usage_limits. Today's task only needs 2 iterations, so the default is fine. Tomorrow we'll add a third tool and watch the model pick among them — that's where loop visibility starts paying off.

Agent loop with pydantic-AI

python

agent = Agent(model)

@agent.tool_plain
def tool_a(...): ...
@agent.tool_plain
def tool_b(...): ...

result = agent.run_sync(prompt)
# pydantic-AI ran the loop until the model emitted a final answer

The library handles:

Sending the prompt + tool schemas
Reading each model response
Detecting tool-call requests and executing them
Feeding tool results back as the next user message
Stopping when the model emits a final answer (or hits the iteration cap)

Inspecting the loop

python

for msg in result.all_messages():
    # each msg has parts: text, tool calls, tool returns
    print(type(msg).__name__)

Message types you'll see:

ModelRequest — what was sent (your prompt + previous tool results)
ModelResponse — what came back (tool call requests OR final text)

For a 2-iteration loop on "2 + 3 then * 4":

Request: "compute 2+3 then multiply by 4"
Response: tool call add(2, 3)
Request: tool result 5
Response: tool call multiply(5, 4)
Request: tool result 20
Response: final text "The answer is 20."

Three LLM calls under the hood. Two tool calls. One run_sync from your perspective.

Configuring iteration limits

python

from pydantic_ai.usage import UsageLimits
limits = UsageLimits(request_limit=10)
result = agent.run_sync(prompt, usage_limits=limits)

For lessons we accept the defaults. For production you'd set explicit caps.

When the agent fails to terminate

If the model calls tools forever (rare but possible with confused tasks), pydantic-AI raises after the iteration cap. Catch it; log; pick a safer prompt or smaller toolset. The loop will terminate one way or another — by completion or by cap.

Today's task

"Compute 2 + 3, then multiply that by 4." Two tools. Final answer 20. Verification asserts "20" in the output.

Sign up to practice

Create a free account to get started. Paid plans unlock all tracks.

or