Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Claude Managed Agents - In Depth and Hands On!

Name: Claude Managed Agents - In Depth and Hands On!
Rating: 4.7 (71 reviews)

Master Claude Managed Agents with Python, MCP, custom tools, memory, and multi-agent workflows

Hot & New

New

Created bySundog Education by Frank Kane, Puria Izady

Last updated 8/2026

English

English [Auto],

What you'll learn

Build a complete personal research agent that uses orchestration, memory, MCP, outcomes, and notifications.
Build and run Claude Managed Agents using the Console, ant CLI, and Python SDK.
Design effective agents with models, system prompts, built-in tools, custom tools, and MCP integrations.
Configure cloud environments, files, vaults, networking, permissions, and safety controls for agentic workflows.
Stream agent events, track tool use and cost, interrupt runs, and build clients that respond to agent activity.
Create outcome-driven agents that use rubrics, iteration, memory stores, and dreaming to improve results.
Orchestrate multi-agent systems for research, writing, fact-checking, coding, and production workflows.
Integrate Managed Agents with GitHub, Google Docs, Linear, Slack, webhooks, and external APIs.

Course content

6 sections • 89 lectures • 6h 5m total length

Introduction: Welcome & Roadmap1:10
Course roadmap & What is an Agent?4:59
We look at the milestones of the course that you will take to understand the Claude Managed Agents components and how you will build the labs until your final capstone project. The final project builds up a multi-agent solution that will perform as a Research Agent for you finding out the latest information on any topic, validating it and storing the results in Google Docs, once done it'll ping you on Slack to inform you.

In the second part we look at the ReAct pattern which defines the software architecture of agents: reasoning, acting/tool execution and observation. This are the fundamental pieces of an agent.
Capstone Project and Udemy Labs4:37
In this lecture we look at the final capstone project that you'll build and how you can use directly Jupyter Notebooks here in Udemy without needing to run the code on your laptop. We also look at the list of tools that you need, like Anthropics Console, Python SDK and CLI.
Bringing Agents to production with Claude Managed Agents7:10
Creating your first agent PoC is easy, it'll take you at max. 5 minutes. But how can you from there really build something that is production ready. We explore the building blocks of a production ready agent including a robust loop, sandboxing, permission management, scaling and observability, and how Claude Managed Agents bridges this gap with a 10x efficiency gain promise.
Roadmap & labs: Key takeaways1:16
Intro: Setting Up Your Workspace1:02
Set up your workspace to run Claude managed agents, creating a spend-capped console account, installing the Ant CLI and Python SDK, and building your first agent in browser and Python.
Setting up Claude Platform account and Cost control6:06
In this lecture we look at how you can setup your workspace in the Claude Platform, charge your account and setup cost control limits.
Claude Platform console tour4:05
In this lecture we look at the components of the Claude Manage Agents platform: Agents, Sessions, Deployments, Environments, Memory, Vault and Webhooks.
Get course materials2:30
Lab: Configure your Claude Platform Account and Claude API Key3:45
In this Lab we're going to configure your Claude Platform Account that will allow you to setup your dedicated workspace, API key and as well show you on how to configure Limits to control your costs.
Lab: Install IDE, UV and clone Git repository6:44
In this Lab we're going to install Visual Studio Code as IDE, install uv as Python package manager and as well clone the Git repository of this course containing all lab projects as Jupyter Notebook files.
Guide (Windows + Linux): Installation of prerequisites python, uv, IDE3:33
Setting up your Workspace: Key takeaways1:05
Set up your cloud account with cost controls and limits, and configure an api key and env file to access managed agents and llms via the console or Python sdk.
Intro: The Agentic Landscape1:09
The Agentic Landscape: Agent Loop, Tools, Memory and Autonomy4:30
Choosing an Agent Stack and Meta Harness10:57
The Agentic Landscape: Key takeaways1:32
Identify the four main ingredients—main loop, tool calls, short-term and long-term memory, and autonomous behavior—and consider cloud managed agents for larger, outcome-based work.
Lab: Create your first Agent in Claude Console13:29
Create your first Claude agent in the Claude Console by configuring an agent with a fib.py script to generate Fibonacci numbers, then run it in a cloud environment session.
Intro: Anatomy of a Managed Agent1:06
Follow a single message from send to result, naming the four core nouns: agent, environment, session, and events, and trace the run across client, harness, model, and container.
Claude Managed Agent: Core Concept & Lifecycle5:31
Inside a running Claude Managed Agent Session4:26
Explore the internal structure of a running Claude managed agent session: a linux-based x86 container with pre-installed languages and databases, plus workspace, output, and temporary folders and the session states.
Anatomy of Claude Manged Agent: Key takeaways0:28
Identify the four components that define the Claude managed agent and its surroundings: the agent template, the environment template, the session that runs the agent, and the cloud platform monitoring.
Lab: Create your first Coding Agent with Claude Managed Agents Python SDK4:45
Lab: Understand automatic Prompt Caching4:25
Lab: Clean Up Agents from Lab 1 and Lab 20:50

Intro: Designing Effective Agents1:07
Design lean, reliable agents by weighing capability, speed, and cost across Opus, Sonnet, and Haiku, and configure system prompts, tools, and versioning to deliver clear, cited briefs.
Design Effective Agents: Select the right model3:34
Select the right model and tools to make agents effective, balancing Opus, Sonnet, and Haiku by task, speed, and cost, and route tasks via a triage entry door.
Design Effective Agents: System Prompt and Saving tokens5:08
Learn to craft concise system prompts for a financial research assistant by defining role, constraints, and tools, saving tokens with structured outputs, and organizing tools with namespaces.
Design Effective Agents : Standard Tools & Versioning3:42
Explore the built-in toolset for Anthropic agents and sandboxing, including read, glob, grab, write, web search, web fetch, bash, python. Enable only needed tools and apply versioning to manage versions.
Design Effective Agents: Key takeaways0:46
Choose Opus, Sonnet, or Haiku by cost, speed, and capability. Define the system prompt with role and tools, use Entropic features to edit, write files, web search, and version agents.
Lab: Research Agent with Web Search and Google Drive MCP Tool13:59
In this Lab we're building a Research Agent that is capable of running Web Search to find the right sources on the web, and prepare a Briefing document on a topic of your choice. We connect the agent via MCP with Google Drive, and this empowers the agent to create Google Docs and store them in your personal Drive. Once done the agent will always generate a briefing doc that is stored in Google Docs with a direct link for you as result.
Intro: Cloud Environments1:06
Create a container-ready environment with pandas and numpy, exactly two allowed domains, and a least-privilege network. Use six package managers, manage archiving, and enable reusable, isolated lab sessions.
Cloud Environments: Container Packages2:14
Configure the agent's sandbox by extending a linux container with package managers (pip, npm, apt, cargo, gem, go), define networking, and pre-install tools like a db client, pandas, and ffmpeg.
Cloud Environments: Network Configuration4:28
Configure secure cloud networking for Claude managed agents by restricting access and listing allowed hosts. Limit prompt injection risks, manage package managers and MCP servers, and archive unused environments.
Cloud Environments: Key takeaways1:32
Configure Linux container cloud environments with preinstalled CLIs, database clients, package managers, and language packages like pandas or matplotlib for agent readiness; apply restricted networking and reuse environments across sessions.
Lab: Data Science Agent with customized Environment8:10
In this lab we build a specialized agent that is capable for data analytics tasks. For that we configure a dedicated environment that has pip packages preinstalled that are useful for data analytics tasks such as pandas and matplotlib. The agent first generate a syntetic revenue data set over 12 months and then generate a visualization with matplotlib and stores it into the workspace of the session. At the end of the lab we download the visualization into your local machine from the agent session.

Intro - The Event Stream1:04
SSE and Event Stream types3:29
Learn how cloud managed agents stream events using SSE over HTTP, with user, agent, session, and span events, and how interrupts and tool-use messages steer and observe long-running agents.
Steering, Interruptions & Cost metering3:55
Explore steering, interruptions, and cost metering for Claude managed agents by tracing states, context prompts, event flows, and token-based pricing in end-to-end interactions.
The Event Stream: Key takeaways0:54
Lab: Agent Session, Events, and Multi-Turn Conversation7:23
In this lab we create a Agent that is being called over a ongoing session 3 times to demonstrate the automatic chat history capabilities of Claude Managed Agents. We further analyze the different event types that are part of the SSE communication between User and Agent inside the Claude Console. Finally in this chapter we dive deeper into how the token consumption of an agent session can be measured in the event payload.
Intro - Custom Tools & MCP1:05
Tools for Agents2:07
Compare native, custom, and MCP tools and learn to build custom tools. Authentication differs: built-in tools require no auth, custom tools may use API keys, MCP uses OAuth.
Custom Tools5:42
MCP Tools5:24
Explore MCP tools and vaults to authenticate with OAuth, integrate MCP servers into your agent, inject credentials securely into tool calls, and manage token rotation.
Custom Tools & MCP: Key takeaways0:39
Lab: Connecting Agent to MCP Tools: Linear and Slack7:42
In this Lab we're creating an Agent that is connected to MCP Tools and loading OAuth Credentials for these MCP servers via the Claude Managed Agents Credentials Vault. We connect the agent to Slack and Linear allowing it to read, prioritize and create new Linear Tickets and as well to read and write messages to your Slack Workspace.
Intro - Permission Policies & Safety1:05
Balance autonomy and safety for managed agents with always allow and always ask, per-tool overrides, prompt-injection defense, and a human-in-the-loop checkpoint for safe, auditable actions.
Permission Policies4:25
Safety in depth against Prompt Injection6:35
Learn practical defense in depth against prompt injection in cloud managed agents, from input controls and guardrails to network limits, read only memory, and vaulted credentials.
Permission Policies & Safety: Key takeaways0:44
Learn how permission policies work, from always allow and always ask, to configuring MCP servers and Anthropic toolsets, while securing cloud managed agents against prompt injection with layered controls.
Lab: Permissions Policies and Human in the loop7:44
Intro - Skills1:08
Author a custom Skill4:37
Author a custom skill by creating a skill.md with name, intro, and a concrete description to guide the agent's load decision, and organize references, scripts, and artifacts for runtime loading.
What are Skills & Pre-Built Skills3:48
Learn how skills empower Claude managed agents to learn workflows and knowledge, using pre-built Excel, Word, PDF, PowerPoint skills, and how they load and integrate with system prompts and tools.
Skills: Key takeaways0:55
Learn the file-based skill structure built from Markdown, including pre-built Excel, Word, PDF, and PowerPoint skills, main skill files, references, helper scripts, and the prompts-skills distinction.
Lab: Skills with Financial Agent using Excel7:42

Intro - Outcomes1:02
Outcome Driven Sessions & The Grader3:34
Outcomes Loop, Rubrics and download Artifacts4:59
Explore the outcome-based loop with builder and grader, including iterations, verdicts, and handling failures or interruptions. Learn to craft measurable, verifiable rubrics and download artifacts from the sandbox outputs.
Outcomes: Key takeaways0:40
Lab: Outcome Based Agent with Grader9:44
Intro - Memory Stores1:05
Explore memory stores that give durable cross-session continuity for agents, covering the store anatomy, seeding and attaching to sessions, safety against memory poisoning, and read-write or read-only choices with rollback.
Memory Stores3:39
Memory Store Security & Versioning4:33
Memory Stores: Key takeaways0:43
Lab: Memory Stores11:51
Create and manage memory stores, including a read-write store for Alice and a shared read-only policy store, to preserve context and refund policy details across sessions.

Intro - Multi-Agent Orchestration1:04
Discover multi-agent orchestration by coordinating researchers, writers, and fact-checkers within a thread budget. Learn when a team helps, how to wire a coordinator to specialists, and keep confirmations simple.
Multi-Agent Orchestration6:10
Explore multi-agent orchestration, showing how a coordinator and specialized sub-agents share threads, route tasks, and escalate in parallel, with guidelines on when to use multi-agent setups.
Multi Agents Threads & Event Routing4:50
Multi-Agents: Key Takeaways1:15
Lab: Multi-Agentic Research Team with Lead, Researcher, Writer & Fact Checker10:57
Intro - FIles & GitHub Workflows1:01
Connect an agent to a repository, fix a failing test, and open a reviewable pull request through a clone-edit-branch workflow. Manage files, sessions, mounts, and secure tokens for scope deliverables.
Files2:37
GitHub Workflows3:20
Mount a GitHub repository as a resource for your agent, use token-based authentication in a sandbox, and leverage the MCP server and vault to push branches and open pull requests.
Files & GitHub Workflows: Key Takeaways1:09
Learn to integrate files via the files api in an agent session, manage limits with copies and zip files, and securely push changes to git repositories via the mcp server.
Intro - Webhooks & Observability1:00
Verify webhook deliveries with signature checks using unwrap. Compare webhooks with streaming, register an endpoint, and build an idempotent, secure handler that posts to Slack and notifies the team.
Webhooks vs. SSE2:52
Webhook Idempotency, Unwrap & Slack3:50
Observability3:49
Explore the observability stack for cloud managed agents, monitoring real-time events, session token usage, and webhook alerts to debug, trace, and optimize agent performance.
Webhooks & Observability: Key Takeaways1:06
Compare sse and webhooks for asynchronous notifications and expose session and agent details. Leverage Entropiq's unwrap to parse webhook payloads, and monitor via the cloud console and observability stack.
Intro - Pricing, Cost Optimization & Production1:05
Learn cost optimization for Claude managed agents, identify what drives the bill, lower it with tokens, prompt caching, and routing by complexity across Haiku, Sonnet, and Opus.
Pricing, Cost Optimization and Production on AWS11:26
Lab - Bug Fixing Agent with GitHub Repo as Resources and MCP for Pull Requests12:29

Intro - Capstone: Personal Research Agent1:05
Build a personal research agent end-to-end with a coordinator and three specialists who research, write, verify against a rubric, and file results to Google Docs with Slack alerts.
Lab - Capstone Project18:09
Build a capstone project that forms a personal research team using Slack, Google Drive, and memory stores to produce a cloud-managed agents briefing via an outcome-based, multi-agent pipeline.
Intro - What's Next0:53
Explore how a managed agent fits in the wider Anthropic ecosystem, covering surfaces, connectors, plugins, trusted MCP servers, design paths, what's on the horizon, and a practical next step.
What's Next7:32
Stay up to date with cloud managed agents using cloud code, cloud cowork, and MCP connectors. Explore plugins, the MCP marketplace, certifications, and cloud design to build robust, secure solutions.
Bonus Lecture1:03

Requirements

Basic Python programming experience, including running scripts, installing packages, and working with environment variables.
Comfort using a command line and a code editor such as VS Code.
A Claude account with access to Claude Managed Agents for the hands-on labs.
Helpful but not required: GitHub and optional integration accounts such as Slack, Google Docs, Linear, or MCP-enabled services.

Description

This course contains the use of artificial intelligence.

AI agents are becoming the next major layer of software development, but most developers are still stuck at the demo stage.

It is one thing to build a chatbot that answers questions. It is another thing to build an agent that can use tools, manage state, work in a cloud environment, interact with external services, follow safety policies, remember useful information, and complete real tasks reliably.

Claude Managed Agents: In Depth and Hands On! is designed to close that gap.

In this course, you will learn how to build practical, production-oriented AI agents using Anthropic’s Claude Managed Agents platform. You will go beyond prompting and learn how managed agents actually work: how they run, how they use tools, how they stream events, how they connect to services through MCP, and how to design agentic workflows that are useful in real applications.

This course deep-dives into Claude Managed Agents, one of the domains on the Claude Certified Developer (CCDV-F) exam, covering managed agent deployment, session management, and Anthropic-hosted agent architecture, useful supplementary prep, not a substitute for full exam study.

You will start with the foundations: what makes an agent different from a chatbot or copilot, how Claude Managed Agents fit into Anthropic’s agentic stack, and how the core building blocks, agents, environments, sessions, and events, work together.

Then you will build agents yourself using the Console and Python SDK. Along the way, you will learn how to:

Design effective agents with models, system prompts, tools, and versioning
Configure cloud environments with packages, networking controls, and least-privilege access
Work with the event stream to monitor tool use, cost, progress, interruptions, and agent state
Extend agents with custom tools, MCP servers, vaults, and per-user authentication
Apply permission policies and safety controls for human-in-the-loop agent workflows
Use Skills, files, GitHub resources, webhooks, and external integrations
Build outcome-driven agents that iterate against rubrics until the task is satisfied
Add memory stores and “dreaming” so agents can retain useful information over time
Orchestrate multiple agents for research, writing, fact-checking, coding, and production workflows

The course includes 15 hands-on labs, leading up to a capstone project where you build a personal research agent that uses orchestration, memory, MCP, outcome evaluation, Slack notifications, and Google Docs integration.

This course is designed for developers, AI engineers, software engineers, solutions architects, technical founders, and Claude Code users who want to move beyond basic prompting and build more serious agentic applications.

Your instructors bring deep real-world experience in AI, cloud architecture, and software engineering.

Frank Kane has taught AI and machine learning to over 1.2 million people around the world. He holds 26 patents in machine learning and spent 9 years at Amazon as a senior engineer and senior manager.

Puria Izady is former Solutions Architect at AWS specializing in Generative AI and Machine Learning, and is the creator behind Pumping Code and the agentic grocery solution Cocoduro.

By the end of this course, you will understand not just how to create a Claude Managed Agent, but how to design, extend, monitor, secure, and integrate agents into real applications.

Who this course is for:

Developers who want to build practical AI agents with Claude Managed Agents, Python, tools, and cloud environments.
AI engineers, software engineers, solutions architects, and technical founders building production-ready agentic workflows.
Claude Code users who want to understand managed agents more deeply and automate larger, more reliable workflows.
Technical learners with basic coding experience who want hands-on labs, not a non-technical introduction to AI.

Claude Managed Agents - In Depth and Hands On!

What you'll learn

Explore related topics

Course content

Foundations and Orientation25 lectures • 1hr 41min

Build Your First Agent11 lectures • 46min

Extending and Running Agents21 lectures • 1hr 18min

State and Goals10 lectures • 42min

Orchestration, Integration, and Production17 lectures • 1hr 10min

Capstone Project and Next Steps5 lectures • 29min

Requirements

Description

Who this course is for: