Build & submit taskBetaintermediate

Build the Canonical Claude Agent Workflow Patterns

Implement the workflow patterns behind real Claude systems: prompt chaining, routing, parallelization, orchestrator-workers, and an evaluator-optimizer loop, then build a router that picks the right one and state when a fixed workflow beats an open-ended agent. Submit a single script or notebook for instant, rubric-based feedback.

3.5 hrs

Est. time

Outcomes

Rubric criteria

65%

Pass score

What you'll learn

Skills you'll have real reps in after shipping this.

Composable workflow patterns

Most production work is covered by a few patterns: chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer.

Routing

Classify first, then dispatch. A specialized prompt per category beats one prompt trying to handle everything.

Evaluator-optimizer

A separate evaluator critiquing against explicit criteria, with bounded iterations, improves quality without looping forever.

Workflow vs agent

Fixed workflows are predictable, cheap, and debuggable. Reserve open-ended agents for genuinely open-ended tasks.

See how it works

The workflow patterns

three orchestration patterns

think→act→observe↺answer

adaptivity90

predictability45

latency (lower is better)55

Reason and act alternate in a loop, each observation shaping the next thought. Most adaptive; can wander or loop without good guards.

Adaptivity and predictability pull against each other. Tool-calling decides one step at a time, fast and simple but shallow. ReAct loops reasoning and acting, the most adaptive and the most prone to wandering, which is why it needs the step budget. Plan-then-execute commits to a plan up front, which is predictable and easy to inspect but slower to start and brittle when reality does not match the plan. There is no best pattern; you pick by how open-ended the task is and how much you value a plan you can read over an agent that improvises.

Chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer. A small set of composable shapes covers most production work.

Workflow vs open agent

the ReAct loop

3/8

THOUGHTI need the user's order total. I should look up their latest order.

ACTIONget_orders(user="u_42", limit=1)

OBSERVATION[{"id": "o_991", "status": "shipped", "total": null}]

Thought, action, observation, repeat. ReAct interleaves reasoning and acting. The model thinks out loud about what to do, takes one action, and reads the observation that comes back, and crucially that observation feeds the next thought. Here the first lookup returns a null total, so the agent reasons that it needs the line items, fetches them, sums them, and only then answers. A model that only reasoned would have guessed; a model that only acted could not adapt. Alternating the two is what makes it an agent.

An open agent decides its own path each turn. A workflow fixes the path in code. Predictable tasks belong in a workflow.

The scenario

Your team keeps reaching for a fully autonomous agent for every problem, even ones that are a fixed sequence of steps. The autonomous version is slower, costlier, and harder to debug than the task needs. Other times they hand a genuinely open-ended task to a rigid pipeline that cannot adapt.

You are going to build the toolbox properly: the small set of composable workflow patterns that cover most production work, plus the judgment to pick the right one. A router classifies the request, a fixed workflow handles the predictable parts, and an evaluator-optimizer loop improves the output where quality matters.

Your role

You are a Claude solutions architect. Your deliverable is one module that implements the canonical workflow patterns as clean, composable building blocks, with a router that selects among them and a clear rationale for workflow versus agent.

Start the task to unlock the full brief

You'll get the step-by-step requirements, setup commands, the 7-criterion grading rubric, tips, and the ability to submit your solution for instant AI grading.

Free to start · submit when you're ready

Learning resources

Building effective agents

The canonical workflow patterns and when to use each.

anthropic.com

Anthropic API: messages

The Messages API used by every pattern.

docs.anthropic.com

Anthropic cookbook

Worked examples of orchestration patterns.

github.com

What you'll build in this agent workflow patterns task

This is a build-and-submit task, not a guided lab. You implement the small set of workflow patterns that cover most production Claude systems: prompt chaining with gates, routing, parallelization, and an evaluator-optimizer loop, plus a router that picks the right one. The deliverable is one Python module of clean, composable building blocks.

The judgment this trains is the one that separates an over-engineered agent from a system that ships: knowing when a predictable task belongs in a fixed workflow and when a problem is open-ended enough to warrant an agent. You build each pattern as a reusable unit, route between them, and improve quality with a bounded evaluator-optimizer loop rather than an unbounded autonomous one.

Grading is rubric-based and explainable. Your submission is scored against weighted criteria (SDK integration, the patterns, routing, parallelization, the evaluator-optimizer loop, workflow-vs-agent reasoning, and the demonstration) with per-criterion feedback quoted from your code. The pass threshold is 65 percent and you can resubmit. These are the orchestration skills the Claude Certified Architect exam weights most heavily.

Frequently asked questions

How is this different from the multi-agent task?

The multi-agent task builds a hub-and-spoke system of autonomous subagents. This task builds the fixed workflow patterns (chaining, routing, parallelization, evaluator-optimizer) and the judgment for when a workflow beats an agent at all. Together they cover the orchestration domain.

Do I need all five patterns?

At least four implemented as distinct units, including an evaluator-optimizer loop. Orchestrator-workers is a plus. The point is to show them as composable building blocks a router can select among.

What makes the evaluator-optimizer bounded?

A hard iteration cap. The generator produces output, a separate evaluator critiques it against explicit criteria, and you stop either when the evaluator passes or after N rounds, so the loop cannot run forever.

What counts as a complete submission?

A single .py or .ipynb on the Anthropic SDK implementing four-plus workflow patterns, a router that selects among them, a bounded evaluator-optimizer loop, a stated workflow-vs-agent rationale, and a demonstration of each pattern.