Building Effective Agents

Learning Objectives

• Distinguish workflows (LLMs on predefined code paths) from agents (LLMs that direct their own work) and explain why the distinction matters
• Recognize the foundational augmented LLM building block (retrieval + tools + memory) underneath every other pattern
• Identify the five workflow patterns — prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer — and pick the right one for a given task
• Decide when full agent autonomy is justified and when a simpler workflow is the better engineering choice
• Apply the agent-computer interface (ACI) principles when designing tools your agent will actually use well

Prerequisites: M00 (Course Overview), M05 (Function Calling), M12 (ReAct Loop) help, but this module is self-contained.  |  Level: Intermediate

Workflows vs. Agents — The Core Distinction

The first — and most important — thing the article does is define its terms. The word “agent” gets used loosely in the industry to mean anything from a chatbot to a fully autonomous robot. Anthropic narrows it down to one specific axis: who decides what step happens next?

When (and When Not) to Use Agents

The article opens with a recommendation that’s easy to read and easy to skip past: find the simplest solution possible, and only increase complexity when needed. It then drives the point home with a sharper version: “This might mean not building agentic systems at all.” Coming from the company that sells the model, that’s a notable thing to print. Take it seriously.

The reasoning is grounded in tradeoffs. Agentic systems trade latency and cost for better task performance on open-ended problems. That trade is worth it for some workloads and a bad deal for others. The decision tree below summarizes the article’s heuristics:

The Augmented LLM — The Foundation Block

Every pattern in the article — chaining, routing, agents, all of them — is built out of one repeating piece: an LLM that has been augmented with three capabilities: retrieval, tools, and memory. Anthropic calls this the “augmented LLM,” and the framing matters: don’t think of the LLM as a chatbot, think of it as a reasoning engine with three plug-in slots.

Pattern 1 — Prompt Chaining

Code: Outline → Draft → Polish

This is the smallest interesting prompt chain. We split “write a short blog post on topic X” into three calls, with a length-check gate between the outline and the draft.

from anthropic import Anthropic, APIError

client = Anthropic()
MODEL = "claude-sonnet-4-6"

def call(system: str, user: str, max_tokens: int = 1024) -> str:
    """One Messages API call. Centralized so error handling stays in one place."""
    try:
        resp = client.messages.create(
            model=MODEL,
            max_tokens=max_tokens,
            system=system,
            messages=[{"role": "user", "content": user}],
        )
        return resp.content[0].text
    except APIError as e:
        # In production, log + retry with backoff. Here we surface the error
        # so the chain halts visibly rather than producing silent garbage.
        raise RuntimeError(f"LLM call failed: {e}") from e

def chain_blog_post(topic: str) -> str:
    # Step 1: outline
    outline = call(
        system="You write tight, structured outlines.",
        user=f"Write a 5-bullet outline for a 300-word blog post about: {topic}",
        max_tokens=400,
    )

    # GATE: did we actually get a structured outline back?
    if outline.count("\n") < 3:
        raise ValueError(f"Outline too short to be useful:\n{outline}")

    # Step 2: draft from the outline
    draft = call(
        system="You expand outlines into clear, engaging prose.",
        user=f"Expand this outline into a 300-word draft. Use the outline order.\n\n{outline}",
        max_tokens=900,
    )

    # Step 3: polish (tighten language, fix awkward phrasing)
    polished = call(
        system="You are an editor. Tighten prose, remove filler, fix awkward sentences.",
        user=f"Polish this draft. Keep the meaning, improve flow.\n\n{draft}",
        max_tokens=900,
    )
    return polished

if __name__ == "__main__":
    print(chain_blog_post("why prompt chaining beats one giant prompt"))

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const MODEL = "claude-sonnet-4-6";

async function call(system, user, maxTokens = 1024) {
  try {
    const resp = await client.messages.create({
      model: MODEL,
      max_tokens: maxTokens,
      system,
      messages: [{ role: "user", content: user }],
    });
    return resp.content[0].text;
  } catch (err) {
    // Halt visibly rather than continuing with bad input downstream.
    throw new Error(`LLM call failed: ${err.message}`);
  }
}

export async function chainBlogPost(topic) {
  // Step 1: outline
  const outline = await call(
    "You write tight, structured outlines.",
    `Write a 5-bullet outline for a 300-word blog post about: ${topic}`,
    400,
  );

  // GATE: structural sanity check before we spend more tokens
  if ((outline.match(/\n/g) || []).length < 3) {
    throw new Error(`Outline too short to be useful:\n${outline}`);
  }

  // Step 2: draft
  const draft = await call(
    "You expand outlines into clear, engaging prose.",
    `Expand this outline into a 300-word draft. Use the outline order.\n\n${outline}`,
    900,
  );

  // Step 3: polish
  const polished = await call(
    "You are an editor. Tighten prose, remove filler, fix awkward sentences.",
    `Polish this draft. Keep the meaning, improve flow.\n\n${draft}`,
    900,
  );
  return polished;
}

const result = await chainBlogPost("why prompt chaining beats one giant prompt");
console.log(result);

Pattern 2 — Routing

Code: Customer-Support Router

A classifier picks one of three lanes — billing, technical, general — and dispatches to a specialized prompt with its own tone and constraints.

from anthropic import Anthropic, APIError

client = Anthropic()
MODEL_FAST = "claude-haiku-4-5-20251001"   # cheap classifier
MODEL_SMART = "claude-sonnet-4-6"          # main answerer

SPECIALISTS = {
    "billing": (
        "You are a billing specialist. Be precise about amounts, dates, and "
        "policies. Never invent fees. If unsure, say so and escalate."
    ),
    "technical": (
        "You are a technical support engineer. Ask for logs/versions when needed. "
        "Suggest one fix at a time. Never guess at internals you don't know."
    ),
    "general": (
        "You are a friendly customer support agent. Answer in 2-3 sentences. "
        "Defer to specialists when the question becomes billing or technical."
    ),
}

def classify(message: str) -> str:
    """Cheap, fast classifier. Returns one of the keys in SPECIALISTS."""
    resp = client.messages.create(
        model=MODEL_FAST,
        max_tokens=10,
        system=(
            "Classify the user message into exactly one label: "
            "'billing', 'technical', or 'general'. "
            "Reply with only the label, no punctuation."
        ),
        messages=[{"role": "user", "content": message}],
    )
    label = resp.content[0].text.strip().lower()
    return label if label in SPECIALISTS else "general"  # safe fallback

def respond(message: str) -> str:
    lane = classify(message)
    try:
        resp = client.messages.create(
            model=MODEL_SMART,
            max_tokens=500,
            system=SPECIALISTS[lane],
            messages=[{"role": "user", "content": message}],
        )
        return f"[lane={lane}] {resp.content[0].text}"
    except APIError as e:
        raise RuntimeError(f"Specialist call failed for lane={lane}: {e}") from e

if __name__ == "__main__":
    print(respond("My credit card was charged twice for last month's plan."))
    print(respond("Login button does nothing on Firefox 124."))

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const MODEL_FAST = "claude-haiku-4-5-20251001";
const MODEL_SMART = "claude-sonnet-4-6";

const SPECIALISTS = {
  billing:
    "You are a billing specialist. Be precise about amounts, dates, and policies. Never invent fees. If unsure, say so and escalate.",
  technical:
    "You are a technical support engineer. Ask for logs/versions when needed. Suggest one fix at a time. Never guess at internals you don't know.",
  general:
    "You are a friendly customer support agent. Answer in 2-3 sentences. Defer to specialists when the question becomes billing or technical.",
};

async function classify(message) {
  const resp = await client.messages.create({
    model: MODEL_FAST,
    max_tokens: 10,
    system:
      "Classify the user message into exactly one label: 'billing', 'technical', or 'general'. Reply with only the label, no punctuation.",
    messages: [{ role: "user", content: message }],
  });
  const label = resp.content[0].text.trim().toLowerCase();
  return SPECIALISTS[label] ? label : "general";   // safe fallback
}

export async function respond(message) {
  const lane = await classify(message);
  try {
    const resp = await client.messages.create({
      model: MODEL_SMART,
      max_tokens: 500,
      system: SPECIALISTS[lane],
      messages: [{ role: "user", content: message }],
    });
    return `[lane=${lane}] ${resp.content[0].text}`;
  } catch (err) {
    throw new Error(`Specialist call failed for lane=${lane}: ${err.message}`);
  }
}

console.log(await respond("My credit card was charged twice for last month's plan."));
console.log(await respond("Login button does nothing on Firefox 124."));

Notice the cost optimization: the classifier uses Haiku (cheap, fast) and the specialist uses Sonnet. You only pay for the smarter model on the work that needs it.

Pattern 3 — Parallelization

Code: Voting-Style Safety Triple-Check

A user-generated post is checked for three risks in parallel: toxicity, off-topic, and contains personal info. Any flag fails the post.

import asyncio
from anthropic import AsyncAnthropic, APIError

client = AsyncAnthropic()
MODEL = "claude-haiku-4-5-20251001"

CHECKS = {
    "toxicity":  "Is this post toxic, hateful, or harassing? Reply only YES or NO.",
    "offtopic":  "The forum is about home gardening. Is this post off-topic? Reply only YES or NO.",
    "pii":       "Does this post contain personal info (full names, phone, email, address)? Reply only YES or NO.",
}

async def check_one(name: str, prompt: str, post: str) -> tuple[str, bool]:
    try:
        resp = await client.messages.create(
            model=MODEL,
            max_tokens=4,
            system=prompt,
            messages=[{"role": "user", "content": post}],
        )
        verdict = resp.content[0].text.strip().upper().startswith("YES")
        return name, verdict
    except APIError:
        # Fail closed: treat unreachable check as a flag, not as a pass.
        return name, True

async def screen_post(post: str) -> dict:
    results = await asyncio.gather(
        *(check_one(n, p, post) for n, p in CHECKS.items())
    )
    flags = {name: flagged for name, flagged in results}
    return {"approved": not any(flags.values()), "flags": flags}

if __name__ == "__main__":
    sample = "Loving my new tomato variety this year, way better than last season's!"
    print(asyncio.run(screen_post(sample)))

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const MODEL = "claude-haiku-4-5-20251001";

const CHECKS = {
  toxicity: "Is this post toxic, hateful, or harassing? Reply only YES or NO.",
  offtopic: "The forum is about home gardening. Is this post off-topic? Reply only YES or NO.",
  pii:      "Does this post contain personal info (full names, phone, email, address)? Reply only YES or NO.",
};

async function checkOne(name, prompt, post) {
  try {
    const resp = await client.messages.create({
      model: MODEL,
      max_tokens: 4,
      system: prompt,
      messages: [{ role: "user", content: post }],
    });
    const flagged = resp.content[0].text.trim().toUpperCase().startsWith("YES");
    return [name, flagged];
  } catch {
    // Fail closed: a missing check counts as a flag, not a pass.
    return [name, true];
  }
}

export async function screenPost(post) {
  const entries = await Promise.all(
    Object.entries(CHECKS).map(([n, p]) => checkOne(n, p, post))
  );
  const flags = Object.fromEntries(entries);
  return { approved: !Object.values(flags).some(Boolean), flags };
}

const sample = "Loving my new tomato variety this year, way better than last season's!";
console.log(await screenPost(sample));

Three calls fire concurrently, so the wall-clock time is roughly one call — about 3× faster than running them sequentially. The fail-closed default in the error handler is deliberate: if a safety check can’t run, treat the post as flagged rather than silently approve it.

Pattern 4 — Orchestrator-Workers

Pattern 5 — Evaluator-Optimizer

Code: Code Reviewer + Author Loop

Generator writes a function. Evaluator checks it for correctness, edge cases, and naming. Up to three revision rounds.

from anthropic import Anthropic, APIError

client = Anthropic()
MODEL = "claude-sonnet-4-6"
MAX_ROUNDS = 3

def llm(system: str, user: str, max_tokens: int = 800) -> str:
    try:
        r = client.messages.create(
            model=MODEL, max_tokens=max_tokens, system=system,
            messages=[{"role": "user", "content": user}],
        )
        return r.content[0].text
    except APIError as e:
        raise RuntimeError(f"LLM error: {e}") from e

def evaluate(code: str, spec: str) -> tuple[bool, str]:
    """Evaluator returns (approved, critique). 'APPROVED' on the first line means done."""
    review = llm(
        system=(
            "You are a strict code reviewer. Check correctness, edge cases, "
            "naming, and style against the spec. Reply with the literal first "
            "line 'APPROVED' if and only if the code fully meets the spec; "
            "otherwise list specific, actionable issues as a bulleted list."
        ),
        user=f"SPEC:\n{spec}\n\nCODE:\n{code}",
        max_tokens=400,
    )
    return review.strip().upper().startswith("APPROVED"), review

def write_with_review(spec: str) -> str:
    code = llm("You write clean, well-named Python.", spec)
    for round_num in range(1, MAX_ROUNDS + 1):
        approved, critique = evaluate(code, spec)
        if approved:
            return code
        # Revise using the specific critique
        code = llm(
            system="You are revising your own code to address reviewer feedback.",
            user=f"SPEC:\n{spec}\n\nYOUR CODE:\n{code}\n\nREVIEWER FEEDBACK:\n{critique}\n\nRevise the code.",
        )
    # Hit the cap; return best effort with a warning
    return f"# WARNING: not approved after {MAX_ROUNDS} rounds\n{code}"

if __name__ == "__main__":
    spec = "Write a Python function `median(nums)` that returns the median of a non-empty list of numbers. Handle even and odd lengths."
    print(write_with_review(spec))

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const MODEL = "claude-sonnet-4-6";
const MAX_ROUNDS = 3;

async function llm(system, user, maxTokens = 800) {
  try {
    const r = await client.messages.create({
      model: MODEL, max_tokens: maxTokens, system,
      messages: [{ role: "user", content: user }],
    });
    return r.content[0].text;
  } catch (err) {
    throw new Error(`LLM error: ${err.message}`);
  }
}

async function evaluate(code, spec) {
  const review = await llm(
    "You are a strict code reviewer. Check correctness, edge cases, naming, and style against the spec. Reply with the literal first line 'APPROVED' if and only if the code fully meets the spec; otherwise list specific, actionable issues as a bulleted list.",
    `SPEC:\n${spec}\n\nCODE:\n${code}`,
    400,
  );
  return [review.trim().toUpperCase().startsWith("APPROVED"), review];
}

export async function writeWithReview(spec) {
  let code = await llm("You write clean, well-named JavaScript.", spec);
  for (let round = 1; round <= MAX_ROUNDS; round++) {
    const [approved, critique] = await evaluate(code, spec);
    if (approved) return code;
    code = await llm(
      "You are revising your own code to address reviewer feedback.",
      `SPEC:\n${spec}\n\nYOUR CODE:\n${code}\n\nREVIEWER FEEDBACK:\n${critique}\n\nRevise the code.`,
    );
  }
  return `// WARNING: not approved after ${MAX_ROUNDS} rounds\n${code}`;
}

const spec = "Write a JavaScript function median(nums) that returns the median of a non-empty array of numbers. Handle even and odd lengths.";
console.log(await writeWithReview(spec));

Pattern 6 — Agents

Code: Minimal Agent Loop

This is the smallest correct agent loop — the article’s recommendation distilled to its essentials. The model picks tools, the harness executes them, the loop continues until the model produces a non-tool response. Note the step cap: a real-world agent must always have one.

from anthropic import Anthropic, APIError

client = Anthropic()
MODEL = "claude-sonnet-4-6"
MAX_STEPS = 10  # hard cap so a confused agent can't loop forever

# 1. Define tools the model can call.
TOOLS = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city. Returns short text.",
        "input_schema": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
    {
        "name": "calculator",
        "description": "Evaluate a basic arithmetic expression like '12 * (3 + 4)'.",
        "input_schema": {
            "type": "object",
            "properties": {"expr": {"type": "string"}},
            "required": ["expr"],
        },
    },
]

def execute_tool(name: str, args: dict) -> str:
    """The harness executes the tool and returns a string result."""
    if name == "get_weather":
        # Stub. In real life: call your weather API.
        return f"{args['city']}: 18C, partly cloudy."
    if name == "calculator":
        # Tightly-scoped eval: numbers and operators only.
        allowed = set("0123456789+-*/(). ")
        if not set(args["expr"]) <= allowed:
            return "ERROR: disallowed characters"
        try:
            return str(eval(args["expr"], {"__builtins__": {}}, {}))  # nosec
        except Exception as e:
            return f"ERROR: {e}"
    return f"ERROR: unknown tool {name}"

def run_agent(goal: str) -> str:
    messages = [{"role": "user", "content": goal}]
    for step in range(MAX_STEPS):
        try:
            resp = client.messages.create(
                model=MODEL, max_tokens=1024, tools=TOOLS, messages=messages,
            )
        except APIError as e:
            return f"ABORTED: {e}"

        # Stop condition: model is done calling tools.
        if resp.stop_reason != "tool_use":
            return next(
                (b.text for b in resp.content if hasattr(b, "text")),
                "(no text response)",
            )

        # Otherwise: append the model's tool calls and run them.
        messages.append({"role": "assistant", "content": resp.content})
        tool_results = []
        for block in resp.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })
        messages.append({"role": "user", "content": tool_results})

    return f"ABORTED: hit MAX_STEPS={MAX_STEPS} without a final answer"

if __name__ == "__main__":
    print(run_agent("What's the weather in Tokyo, and what's 17% of the temperature?"))

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const MODEL = "claude-sonnet-4-6";
const MAX_STEPS = 10;

const TOOLS = [
  {
    name: "get_weather",
    description: "Get current weather for a city. Returns short text.",
    input_schema: {
      type: "object",
      properties: { city: { type: "string" } },
      required: ["city"],
    },
  },
  {
    name: "calculator",
    description: "Evaluate a basic arithmetic expression like '12 * (3 + 4)'.",
    input_schema: {
      type: "object",
      properties: { expr: { type: "string" } },
      required: ["expr"],
    },
  },
];

function executeTool(name, args) {
  if (name === "get_weather") {
    return `${args.city}: 18C, partly cloudy.`;
  }
  if (name === "calculator") {
    if (!/^[0-9+\-*/(). ]+$/.test(args.expr)) return "ERROR: disallowed characters";
    try { return String(Function(`"use strict"; return (${args.expr});`)()); }
    catch (e) { return `ERROR: ${e.message}`; }
  }
  return `ERROR: unknown tool ${name}`;
}

export async function runAgent(goal) {
  const messages = [{ role: "user", content: goal }];
  for (let step = 0; step < MAX_STEPS; step++) {
    let resp;
    try {
      resp = await client.messages.create({
        model: MODEL, max_tokens: 1024, tools: TOOLS, messages,
      });
    } catch (e) {
      return `ABORTED: ${e.message}`;
    }

    if (resp.stop_reason !== "tool_use") {
      const text = resp.content.find((b) => b.type === "text");
      return text ? text.text : "(no text response)";
    }

    messages.push({ role: "assistant", content: resp.content });
    const toolResults = [];
    for (const block of resp.content) {
      if (block.type === "tool_use") {
        const result = executeTool(block.name, block.input);
        toolResults.push({
          type: "tool_result",
          tool_use_id: block.id,
          content: result,
        });
      }
    }
    messages.push({ role: "user", content: toolResults });
  }
  return `ABORTED: hit MAX_STEPS=${MAX_STEPS} without a final answer`;
}

console.log(await runAgent("What's the weather in Tokyo, and what's 17% of the temperature?"));

Combining Patterns — Real Systems Mix Them

The article makes one final point that’s easy to miss because it’s phrased gently: “These building blocks aren’t prescriptive. They’re common patterns that developers can shape and combine to fit different use cases.” In other words: don’t pick exactly one. Real production systems compose them.

Three useful compositions:

• Routing → (specialized chain or agent): A top-level router classifies the request, then dispatches to either a deterministic chain (cheap, predictable cases) or a full agent (rare, open-ended cases). Most customer-support stacks look like this.
• Agent with workflow tools: Inside an agent, individual “tools” can themselves be deterministic workflows. The agent calls a tool that internally does prompt-chaining to summarize a document — the agent doesn’t see that complexity.
• Orchestrator-workers with evaluator-optimizer per worker: A research orchestrator spawns subagents, and each subagent runs a generator-critic loop on its draft before returning. M14 + M17 patterns combined.

Tool Engineering — The Agent-Computer Interface (ACI)

Late in the article, Anthropic devotes a section to a topic that often gets shortchanged: how you design the tools the agent uses. They coin the term Agent-Computer Interface (ACI) — the agent’s analog of HCI. The takeaway: invest as much effort in the ACI as you’d invest in a UI for a human.

The ACI checklist (from the article and surrounding Anthropic guidance)

• Give the model enough tokens to think before acting. Don’t cap output so tightly that the agent skips reasoning. Allow space for a brief plan before each tool call.
• Keep formats close to what the model sees naturally on the open web. JSON, markdown, plain English — not bespoke binary formats or custom DSLs. Models are dramatically better at common formats they’ve seen during training.
• Eliminate formatting overhead. Don’t require the model to count whitespace, escape exotic characters, or maintain rigid line numbers. Every char of overhead is one more thing to get wrong.
• Test extensively with example inputs. Run the tools against realistic inputs and read the model’s tool calls. You’ll spot ambiguities the schema didn’t catch.
• Apply poka-yokeJapanese for “mistake-proofing.” A design principle from manufacturing: shape the tool so common mistakes are physically/structurally impossible to make. design. Shape the tool so common errors are impossible. The article’s classic example: their coding agent kept generating relative file paths that broke when the working directory shifted, so they redesigned the tool to require absolute paths only — the bug class disappeared.
• Document the tool the way you’d document it for a junior engineer. What does it do, what are the inputs, what does it return, what errors can it produce, what should the caller do about each error? The model reads the description and acts on it.

Real Applications — Where These Patterns Show Up

The article’s appendix grounds the abstract patterns in two well-developed real applications. Both are worth understanding because they show what “the right pattern” looks like once a real production constraint is involved.

Customer Support

Customer support combines a chatbot interface with tool integration to access customer data, history, and account systems — and to take actions like issuing refunds or updating tickets. The article identifies it as a strong fit because:

• The interaction is naturally conversational (LLMs are good at this).
• Success is measurable: did the issue get resolved? Was the customer satisfied?
• Pricing per resolution maps cleanly to value — one of the rare AI use cases where outcome-based pricing actually works.

The architecture is typically routing-at-the-top (intent classification) plus a constrained agent in each lane that has access to the tools relevant to that intent — refund tools for the billing lane, account tools for the account lane, and so on. Pure free-form agents are usually overkill.

Coding Agents

Coding agents (the SWE-bench category) are the article’s flagship example of when full agent autonomy is justified. The reasoning:

• Solutions are verifiable through automated tests — the agent doesn’t need a human in the loop on every step because the test suite is the ground truth.
• The agent can iterate using test results as feedback: try a fix, run tests, see what failed, try a refined fix.
• The problem space is genuinely open-ended — the agent might need to read 3 files or 30, edit 1 line or rewrite a module — impossible to pre-script.

Even here, the article tempers the autonomy: “human review remains crucial for ensuring solutions align with broader system requirements.” The PR review step is the human guardrail. The agent works inside a sandbox; humans gate what gets merged.

Knowledge Check

Module Summary

Key Concepts

• Workflows vs. agents: The line is who decides the path. Workflows: predefined code paths you wrote. Agents: LLM dynamically directs itself.
• Start simple: A bare LLM call beats a chain. A chain beats an agent. Reach for the next pattern only when the simpler one provably fails.
• Augmented LLM: The reusable building block under everything. Retrieval + tools + memory, with each capability tailored to the use case.
• Five workflow patterns: Prompt chaining (sequential), routing (classify and dispatch), parallelization (concurrent for speed or voting), orchestrator-workers (runtime decomposition), evaluator-optimizer (generator + critic loop).
• Full agents: Worth the cost only for open-ended problems where steps are unknowable in advance and you can sandbox + add guardrails. Customer support and coding agents are the canonical fits.
• ACI: Tool design is the highest-leverage intervention most teams ignore. Better tools beat better prompts.
• Combining patterns: Real systems are trees — a workflow at the top, agents at the leaves, more workflows inside the agents.

How This Maps to the Rest of the Course

Where to Go Next

Pick the pattern that matches your current project and dive into the corresponding course module. If you’re unsure where you are: most teams overestimate how much agent autonomy they need. Try the simpler pattern first — you can always escalate when your eval set proves it’s necessary.