Claude Certified Architect: Foundations Exam Guide - 2026

In this lecture, you'll set up the complete development environment required for building Claude AI agents in Python. You'll create a virtual environment, install the required dependencies, configure the Anthropic API, and explore the structure of a simple order support agent. You'll also understand how the agent interacts with tools, processes user requests, and uses the stop_reason field to determine whether to invoke a tool or generate a final response.

In this lecture, you will learn:

• How to set up a Python virtual environment for AI agent development

• How to install project dependencies using a requirements.txt file

• How to configure the Anthropic API key using a .env file

• The purpose of helper files, mock data, and reusable tools in an AI agent project

• How a single order support agent is structured and processes customer requests

• How the stop_reason field controls tool execution and agent responses

• The workflow of tool calling within a Claude-powered AI agent

• What to expect in the upcoming hands-on execution and anti-pattern demonstration lectures

In this lecture, you'll execute your first Claude-powered AI agent and observe how it responds to real customer queries. You'll learn how the agent uses the stop_reason field to decide whether to invoke tools or return a final response, and why relying on this mechanism is far more reliable than checking for arbitrary keywords. You'll also explore an anti-pattern implementation to understand common mistakes that should be avoided when building AI agents.

In this lecture, you will learn:

• How to run a Claude-powered AI agent from the command line

• How the order support agent processes customer requests step by step

• How the stop_reason field determines whether to use a tool or return a final answer

• How tool calls enable the agent to retrieve customer, order, and refund information

• Why providing complete user information affects the agent's workflow

• Why checking for random response text or keywords is an unreliable agent design pattern

• How an anti-pattern implementation can lead to incorrect or premature agent termination

• Best practices for building robust and predictable AI agent workflows using stop_reason

In this lecture, you'll enhance your AI agent architecture by introducing a coordinator agent that delegates work to specialized sub-agents. You'll explore how task spawning, explicit context passing, and parallel execution make multi-agent systems more organized, scalable, and efficient. You'll also compare this recommended approach with an anti-pattern implementation to understand why proper context management is essential for reliable AI agent workflows.

In this lecture, you will learn:

• How a coordinator agent delegates work to specialized sub-agents

• How task spawning improves the organization and consistency of AI workflows

• How explicit context passing enables sub-agents to share relevant information

• How parallel task execution improves the efficiency of multi-agent systems

• How a coordinator combines outputs from multiple sub-agents into a final response

• How to execute and test a multi-agent coordinator using sample customer support scenarios

• Why directly invoking sub-agents without proper task coordination is an anti-pattern

• Best practices for designing scalable and maintainable multi-agent architectures

In this lecture, you'll build a more advanced coordinator agent that can handle multiple user requests within a single conversation. You'll learn how the coordinator decomposes a complex request into individual concerns, identifies dependencies between them, executes independent tasks in parallel, and combines the results into a single, coherent response. You'll also compare this approach with an anti-pattern implementation that skips request decomposition.

In this lecture, you will learn:

• How a coordinator agent decomposes a complex user request into multiple concerns

• How to identify independent and dependent tasks within a single user message

• How independent concerns can be executed in parallel to improve efficiency

• How dependent concerns are executed sequentially with proper context passing

• How a coordinator combines results from multiple sub-agents into a unified response

• How to execute and test a multi-concern AI agent using real customer support scenarios

• Why sending an entire user request directly to a single sub-agent is an anti-pattern

• Best practices for designing AI agents that efficiently manage multiple user intents in a single conversation

In this lecture, you'll learn how to use pre-tool and post-tool hooks to add validation, control, and output processing to your AI agents. You'll explore how hooks automatically execute before and after tool calls, allowing you to enforce business rules, block invalid operations, escalate requests when necessary, and format tool outputs before they are returned to the user.

In this lecture, you will learn:

• What pre-tool and post-tool hooks are and why they are important in AI agent workflows

• How pre-tool hooks validate requests before a tool is executed

• How business rules can prevent tool execution and trigger escalation when required

• How refund requests can be automatically approved or escalated based on policy conditions

• How post-tool hooks clean, format, and standardize tool outputs before they reach the agent

• How to execute and test hook-based AI agents using real customer support scenarios

• How hooks improve the reliability, security, and consistency of AI agent behavior

• Best practices for implementing pre-processing and post-processing logic around tool execution

In this lecture, you'll explore dynamic adaptive planning, where an AI agent continuously updates its execution plan based on information discovered during each step. Instead of following a fixed workflow, the agent analyzes intermediate results, revises its strategy, and determines the next best action until the user's request is fully resolved.

In this lecture, you will learn:

• What dynamic adaptive planning is and when it should be used in AI agents

• How an AI agent creates an initial execution plan from a vague or incomplete user request

• How the agent revises its plan after each step based on newly discovered information

• How sequential tasks are executed when each step depends on the results of the previous one

• How the agent investigates customer orders, identifies issues, and applies relevant policies dynamically

• How dynamic planning enables agents to solve complex, multi-step customer requests

• How to execute and observe an adaptive planning agent in a real customer support scenario

• Best practices for designing AI agents that can reason, adapt, and refine their workflows as new information becomes available

In this lecture, you'll learn how AI agents manage conversations across multiple sessions. You'll explore how to create named sessions, resume previous conversations, fork existing sessions into new workflows, update session context with new information, and start fresh while preserving a concise summary. These techniques help build AI agents that maintain long-term context and support flexible conversation management.

In this lecture, you will learn:

• How to create and manage named sessions for AI agent conversations

• How session history is stored and reused across multiple interactions

• How to resume a previous session while preserving conversational context

• How to fork an existing session into a new branch without losing prior context

• How to update an active session by informing the agent of new changes

• How to start a fresh session using a summarized version of previous conversations

• How session files store conversation history and metadata

• Best practices for building AI agents with persistent memory and effective session management

In this lecture, you'll explore why tool descriptions play a critical role in Model Context Protocol (MCP) applications. You'll learn how clear, well-defined tool descriptions help AI models select the correct tool for a given task, while vague or overlapping descriptions can lead to incorrect tool selection. You'll also compare a well-designed implementation with an anti-pattern to understand the importance of effective tool documentation.

In this lecture, you will learn:

• Why tool descriptions are essential for accurate tool selection in MCP-based AI agents

• How AI models use tool descriptions to determine which tool to invoke

• The characteristics of a well-written tool description, including purpose, inputs, and usage

• Why vague or overlapping tool descriptions can result in incorrect tool selection

• How to define tool schemas with clear names, descriptions, and input parameters

• How to execute and test MCP tools using real document search scenarios

• How poorly described tools lead to unpredictable behavior in an anti-pattern implementation

• Best practices for designing descriptive, unambiguous tools that improve AI agent reliability and accuracy

In this lecture, you'll learn how to implement structured error responses in AI agents instead of relying on generic error messages. You'll explore how structured error objects provide detailed information about validation, permission, and execution failures, making debugging, monitoring, and error handling significantly more reliable. You'll also compare this approach with an anti-pattern that returns vague, unhelpful error messages.

In this lecture, you will learn:

• Why structured error responses are preferable to generic error messages in AI agents

• How to use an is_error flag to distinguish successful responses from failures

• How to categorize errors such as validation, permission, and execution failures

• How structured error responses improve debugging and troubleshooting

• How to implement descriptive error handling within MCP tools

• How to execute and test structured error scenarios using document access examples

• Why generic "operation failed" responses are considered an anti-pattern

• Best practices for designing consistent, informative, and machine-readable error responses for AI agent workflows

In this lecture, you'll learn how to control tool selection in MCP-based AI agents using tool choice. You'll explore the different tool choice modes—auto, any, and forced tool selection—and understand when each should be used. You'll also compare a well-scoped implementation with an anti-pattern that exposes too many tools without proper selection logic.

In this lecture, you will learn:

• What tool choice is and how it influences tool selection in AI agents

• The differences between auto, any, and forced tool selection modes

• When to force the model to invoke a specific tool for predictable behavior

• When allowing the model to choose any appropriate tool is beneficial

• How automatic tool selection enables the model to answer directly when no tool is required

• How to configure and test different tool choice strategies in an MCP-based agent

• Why exposing too many tools without proper scoping is an anti-pattern

• Best practices for designing reliable and efficient AI agents with controlled tool invocation

In this lecture, you'll learn how to integrate external MCP servers into your AI agent applications. You'll understand the purpose of MCP servers, how to configure them using project-level and user-level configuration files, and how to securely manage environment-specific settings. You'll also explore the role of the FastMCP library and learn the differences between shared team configurations and local user configurations.

In this lecture, you will learn:

• What an MCP server is and how it extends the capabilities of AI agents

• How to configure MCP servers using the project-level .mcp.json file

• How to configure user-specific MCP servers using the home directory .claude.json file

• The differences between repository-level and user-level MCP server configurations

• How to build and expose MCP tools using the FastMCP library

• How to securely manage API keys and other sensitive settings using environment variables

• Why .env files should not be committed to source control and how .gitignore helps protect secrets

• Best practices for integrating, configuring, and sharing MCP servers across individual and team development environments

In this lecture, you'll explore several built-in tools commonly used in AI agent workflows for interacting with files and source code. You'll learn how to locate files, search file contents, read and modify files, and create new files using practical Python examples. These tools form the foundation for building AI agents that can inspect, analyze, and update codebases efficiently.

In this lecture, you will learn:

• How the Glob tool locates files based on filename patterns and extensions

• How the Grep tool searches for specific text or patterns within files

• How the Read tool opens and retrieves the contents of a file

• How the Write tool creates new files or replaces existing file contents

• How the Edit tool modifies only selected portions of an existing file

• How to implement these file operation tools within an AI agent using Python

• When to use each built-in tool for different file management and code analysis tasks

• Best practices for integrating file system tools into AI-powered agent workflows

In this lecture, you'll set up Claude Code on your local machine and learn how to use it to analyze an existing Python project. You'll install the Claude CLI, authenticate your account, explore the basic workflow, and see how Claude Code can quickly understand a codebase, answer project-related questions, and identify key files without requiring you to manually inspect the source code.

In this lecture, you will learn:

• How to install and configure Claude Code on your local development machine

• How to authenticate using a Claude subscription or other supported login methods

• How to launch and use Claude Code from the command line and Visual Studio Code

• How to explore a sample Trip Planner CLI application using Claude Code

• How to execute and test a simple Python CLI application before analyzing it

• How to ask Claude Code questions about an unfamiliar codebase and receive contextual answers

• How Claude Code identifies important project files and explains their responsibilities

• Best practices for getting started with Claude Code to understand, navigate, and analyze software projects efficiently

In this lecture, you'll learn how Claude Code uses CLAUDE.md files to define coding rules, project memory, and development conventions. You'll explore the different scopes of CLAUDE.md files, understand how rule inheritance and imports work, and see how Claude Code automatically applies these instructions while analyzing and assisting with your codebase.

In this lecture, you will learn:

• What CLAUDE.md files are and how they provide rules and memory for Claude Code

• The differences between user-level, project-level, and folder-level CLAUDE.md files

• How rule precedence and inheritance work across different CLAUDE.md scopes

• How to reuse common rules by importing Markdown files into a project-level CLAUDE.md

• How to define path-specific rules for selected files and directories

• How to inspect the active memory and loaded CLAUDE.md files using Claude Code

• How to ask Claude Code questions about project rules, coding standards, and folder-specific conventions

• Best practices for organizing, sharing, and maintaining reusable coding standards and project memory with CLAUDE.md files