Learning Objectives

• Design and implement multi-step agentic workflows using Claude’s tool-use and orchestration APIs
• Configure and extend the Model Context Protocol to expose custom tools and resources to Claude
• Apply Claude’s extended thinking feature to complex reasoning tasks and interpret chain-of-thought outputs
• Integrate the Claude computer-use API to automate GUI-based tasks within controlled environments
• Build retrieval-augmented generation pipelines that connect Claude to structured and unstructured knowledge sources
• Construct evaluation harnesses to measure agent accuracy, latency, cost, and failure modes systematically
• Deploy Claude-based agents on AWS Bedrock and Google Vertex AI with appropriate IAM, logging, and scaling configurations
• Implement guardrails, fallback logic, and observability tooling to keep agentic systems reliable in production
• Manage context windows efficiently across long-running multi-turn agent sessions
• Diagnose and remediate common failure patterns in agentic loops including tool errors, hallucinations, and infinite cycles

Course Outline

Module 1: Claude API Deep Dive and SDK Internals

Students begin with a rigorous review of the Claude Messages API beyond basic usage. This module covers the full request/response schema, streaming responses, stop reasons, token accounting, and rate-limit handling. Students examine how the Python and TypeScript SDKs are structured and write low-level retry and backoff logic from scratch to understand what the SDK abstracts away.

Module 2: Prompt Architecture for Agentic Systems

Effective agentic prompts differ significantly from single-turn prompts. This module covers system prompt design for persistent agent identity, structuring multi-role conversations, injecting dynamic context without blowing the context window, and prompt versioning strategies. Students practice writing prompts that remain stable across long tool-use loops and varied user inputs.

Module 3: Extended Thinking: Capabilities and Practical Use

Claude’s extended thinking feature exposes internal chain-of-thought reasoning before a final response is produced. This module explains when extended thinking improves output quality, how to enable and configure thinking budget tokens, and how to parse and log thinking blocks programmatically. Students run comparative experiments on multi-step math, code debugging, and ambiguous instruction tasks to measure the tradeoffs in latency and cost.

Module 4: Tool Use and Function Calling Patterns

This module systematically covers Claude’s tool-use protocol: defining JSON schemas for tools, handling tool_use and tool_result content blocks, and managing multi-turn tool loops. Students implement a set of real tools including a web search stub, a database query function, and a file-system reader, then wire them into a working agent that decides autonomously when and how to call each tool.

Module 5: Model Context Protocol (MCP): Architecture and Setup

The Model Context Protocol standardizes how hosts, clients, and servers expose tools and resources to AI models. This module covers the MCP specification, transport options (stdio and HTTP/SSE), and the lifecycle of an MCP session. Students install and run an MCP server locally, inspect the protocol messages with a debug proxy, and connect Claude to it using the official SDK.

Module 6: Building Custom MCP Servers

Students build two custom MCP servers from scratch: one that exposes a SQL database as a queryable resource, and one that wraps an internal REST API as a set of callable tools. The module covers server-side input validation, error response formatting, authentication patterns, and how to structure resource URIs. Students test each server end-to-end with a Claude client before moving to orchestration.

Module 7: Multi-Step Tool Orchestration and Agent Loops

Moving beyond single tool calls, this module covers designing robust agent loops: detecting when a task requires sequential versus parallel tool calls, managing intermediate state between steps, and writing deterministic loop termination conditions. Students build an orchestrator class that wraps Claude and enforces maximum iteration limits, handles unexpected stop reasons, and logs every step for later inspection.

Module 8: Computer-Use API: Integration and Safety

Claude’s computer-use capability allows the model to observe screenshots and issue mouse, keyboard, and scroll actions. This module explains the computer-use tool schema, how to run a sandboxed virtual desktop environment for safe experimentation, and how to stream screenshots back to Claude iteratively. Students automate a multi-step browser workflow and examine the safety constraints and failure modes of giving an AI model GUI control.

Module 9: Context Window Management in Long-Running Agents

Long agentic sessions accumulate large message histories that can exceed context limits and inflate costs. This module covers sliding-window truncation, summarization-based compression, caching with Claude’s prompt caching feature, and selective retention strategies that preserve tool results but compress conversational filler. Students instrument an agent to track token usage per turn and apply a compression strategy that keeps sessions under a configurable budget.

Module 10: Retrieval-Augmented Generation Architectures

This module covers RAG patterns suited to agentic Claude systems: naive RAG, reranking pipelines, hybrid keyword-plus-vector search, and agentic RAG where Claude decides what to retrieve and when. Students build a pipeline using a vector store (pgvector or Pinecone), an embedding model, and a retrieval tool exposed to Claude. The module addresses chunking strategies, metadata filtering, and how to format retrieved passages for reliable citation.

Module 11: Multi-Agent Architectures and Subagent Delegation

Some tasks benefit from routing subtasks to specialized subagents. This module covers orchestrator-worker patterns, how to spawn and communicate with subagents using Claude, and how to aggregate results from parallel subagent calls. Students implement a two-tier architecture where a planner agent decomposes a research task and delegates retrieval, summarization, and formatting to three worker agents, then merges their outputs.

Module 12: Evaluation Harness Design and Benchmarking

Measuring agent quality requires more than manual review. This module covers building automated evaluation harnesses: defining task datasets, writing reference-based and model-graded scoring functions, tracking pass rates across agent versions, and running regression tests after prompt or tool changes. Students build a lightweight eval framework that runs a suite of tasks against their agent, scores outputs with a Claude-as-judge pattern, and writes results to a structured report.

Module 13: Guardrails, Fallback Logic, and Error Handling

Production agents fail in predictable and unpredictable ways. This module covers designing explicit fallback paths for tool failures, handling malformed tool arguments, detecting and breaking infinite loops, and applying input and output guardrails to prevent policy violations or dangerous actions. Students add a guardrail layer to their orchestrator that classifies tool errors, routes recoverable failures to a retry path, and escalates unrecoverable failures to a human-review queue.

Module 14: Observability, Logging, and Tracing for Agents

Debugging a live agentic system requires structured telemetry. This module covers what to log at each step of an agent loop, emitting structured JSON logs with span IDs that trace a full task execution, integrating with OpenTelemetry, and building a simple dashboard to visualize task completion rates, average step counts, and error types. Students instrument their existing agent so that every tool call, model response, and decision point is traceable from a single trace ID.

Module 15: Deploying Claude Agents on AWS Bedrock

AWS Bedrock provides managed access to Claude with enterprise IAM integration and VPC support. This module covers enabling Claude models in Bedrock, using the Bedrock Converse API for tool use, configuring cross-account IAM roles and resource policies, packaging an agent as a Lambda function or container on ECS, and setting up CloudWatch logging and alarms. Students deploy their orchestrator to AWS and run a full end-to-end test against the Bedrock endpoint.

Module 16: Deploying Claude Agents on Google Vertex AI

Vertex AI offers Claude via Model Garden with GCP-native IAM and integration into Vertex Pipelines. This module covers authenticating with service accounts and Workload Identity, calling Claude through the Vertex AI SDK, deploying the agent as a Cloud Run service, and connecting it to Vertex AI Feature Store or BigQuery for RAG lookups. Students configure a Cloud Run deployment with environment-based secrets management and verify logging in Cloud Logging.

Module 17: Cost Modeling, Optimization, and Scaling

Running agentic systems at scale requires deliberate cost management. This module covers calculating per-task token costs across multi-step loops, identifying the highest-cost steps, applying prompt caching to reduce repeated context costs, choosing between model tiers for subtasks, and setting hard budget limits per session. Students profile their deployed agent against a benchmark task set and implement at least two optimizations that reduce cost per task without degrading eval scores.

Module 18: Capstone: End-to-End Agentic System Build and Review

Students spend the final module designing and completing a capstone agentic system that integrates the major topics from the course: a custom MCP server, a RAG retrieval tool, multi-step orchestration with at least three tools, extended thinking on a designated reasoning step, an evaluation harness with five or more test cases, and a deployment target on either Bedrock or Vertex AI. Each student or pair presents their architecture, demonstrates the running system, walks through eval results, and receives structured feedback from the instructor.