agent-sdk-workshop: Anthropic’s Agent SDK Workshop Turns Agent Design Into a Set of Switches

Most agent tutorials make you start with nothing. This repo starts with something working, then lets you turn on tools, subagents, and memory one layer at a time. That changes the lesson from “how do I wire this up?” to “what actually changes when capability enters the system?”

Why This Workshop Feels Different

The clever part is pedagogical, not decorative. Instead of hiding complexity behind a polished demo or scattering it across a dozen files, the workshop turns the agent into a controlled experiment. One flag changes behavior. Another adds delegation. Another makes the agent remember what happened before.

That makes the repo unusually legible for busy engineers. You can see the shape of the harness before you worry about prompt polish. And that matters, because most agent failures are not model failures. They are orchestration failures.

The Switchboard: Tools, Subagents, and Memory

What agent.py Is Really Doing

The technical core sits in build_options(). That function assembles a ClaudeAgentOptions object from feature flags in config.py, then hands those options to the client runtime. The important idea is not the syntax. It is that the workshop makes the agent’s behavior a function of configuration, not a pile of one-off prompt tricks.

def build_options():
    options = ClaudeAgentOptions()

    if ENABLE_TOOLS:
        options.allowed_tools = research_server.tools

    if ENABLE_SUBAGENTS:
        options.agents = [researcher, fact_checker]

    if ENABLE_MEMORY:
        options.hooks = [memory_hook]

    return options

client = ClaudeSDKClient(options=build_options())

That structure is why the workshop lands. The main agent does not become magical. It becomes inspectable. You can trace the path from prompt to options to runtime behavior, then watch the same request change shape when a tool or subagent is present.

Why Subagents Matter More Than They First Look

Subagents are the repo’s strongest delegation lesson. They are not a novelty layer pasted on top of chat. They are a way to give the main agent specialized workers with narrower jobs, separate prompts, and their own tool access.

That separation changes reliability. A monolithic agent has to do everything in one context. A subagent can be asked to research, verify, or summarize without dragging the whole conversation into every step. In practice, that is closer to how teams work.

Why Local Mock Data Is a Feature, Not a Shortcut

The workshop uses static JSON in mock_data/ and data/ to keep the learning loop stable. That is not a compromise. It is the point. A live API can be useful later, but it obscures the lesson when you are trying to understand how tools, delegation, and memory change the agent’s behavior.

Deterministic data makes the demo repeatable. The same input produces the same output, so the reader can isolate the effect of each switch. For a workshop, that is more valuable than realism.

How the Guided Demo Becomes a Real Workflow

The repo does not stop at a single guided demo. It moves from a monolithic teaching path into breakouts for roles like SRE, customer support, and chief of staff, then into extend templates for custom integrations. That progression matters because it shifts the user from observing primitives to composing systems.

In other words, the workshop is not just teaching features. It is teaching a workflow for assembling agents from reusable parts. Once that clicks, the SDK stops feeling like a prompt wrapper and starts feeling like an operating harness.

Where This Fits in the Agent Framework Landscape

Compared with broader orchestration frameworks, the workshop is unusually strong at teaching the harness layer. LangGraph is often the answer when you need explicit graphs and stateful routing. OpenAI’s Agents SDK emphasizes handoffs in its own ecosystem. This repo is different: it teaches how Claude’s agent runtime becomes legible when you expose configuration, hooks, and delegation directly.

That is the main value here. The repo is not trying to win a framework bake-off. It is trying to make the model’s surrounding machinery visible, which is the part most teams underestimate.