Developers who can build reliable AI agents will create applications that go far beyond ordinary chatbots and prompting interfaces.
A chatbot responds to a message. A more capable agent can use tools, interact with external systems, retain information, evaluate its own work, and continue taking action until it reaches a defined goal.
Learning to build those systems is the focus of our new course:
Claude Managed Agents: In Depth and Hands On!
I created this course with Puria Izady of Pumping Code to give developers a practical path from basic agent concepts to complete, integrated agentic applications – using Anthropic’s new Claude Managed Agents system that lets you run your applications entirely in the cloud.
The course is now available on Udemy. For a limited time, you can enroll for $9.99 using the following coupon:
https://www.udemy.com/course/claude-managed-agents/?couponCode=CLAUDE-AGENTS
Introductory pricing expires July 25, 2026.
Why agent development is becoming an important skill
Most developers have already experimented with large language models. They have written prompts, used a chat interface, or called a model API.
Those are useful starting points, but they do not address many of the difficult questions involved in building a real application:
- How does the model safely interact with tools?
- Where does the agent run?
- How do you monitor what it is doing?
- What state persists between interactions?
- How does it authenticate with external services?
- How do you prevent destructive or unauthorized actions?
- How can an agent determine whether it has actually completed its task?
- When should you use one agent, and when should you coordinate several?
- How do you control latency and cost in production?
These are software-engineering and system-design problems, not just prompting problems.
Claude Managed Agents provide a managed environment for addressing many of them. The platform brings together agents, cloud environments, sessions, events, tools, integrations, outcomes, and memory within a common architecture.
Our course teaches you how those components work and, more importantly, how to use them yourself.
What you will be able to build
By the end of the course, you will be able to design Claude agents that operate in cloud environments, use tools, connect to external services, retain useful information, and work toward clearly defined outcomes.
You will learn how to:
Design effective agents
You will configure agents using appropriate Claude models, focused system prompts, built-in tools, tool overrides, and versioning.
We also examine how to keep prompts and tool results concise so the agent receives the information it needs without wasting tokens or increasing costs unnecessarily.
Create and secure cloud environments
Managed agents run in cloud containers. You will learn how to configure these environments, install the packages your application needs, control network access, reuse environments, and apply least-privilege principles.
Understand what an agent is doing
An agent may perform many actions during a single run. You need visibility into those actions if you intend to build a reliable application.
The course shows you how to work with the event stream to observe messages, tool calls, progress, interruptions, state changes, usage, and cost.
Connect agents to tools and external services
Useful agents rarely operate in isolation.
You will learn when to use built-in tools, custom tools, or Model Context Protocol integrations. You will also work with MCP servers, vaults, OAuth credentials, and per-user authentication.
Add safety controls
Giving an agent access to tools creates new risks.
The course covers permission policies, confirmation flows, restricted networking, prompt-injection threats, vault scoping, memory protection, and human-in-the-loop checkpoints.
These controls allow you to balance useful autonomy against the need for oversight.
Use Skills and files
You will learn how to attach Anthropic’s document and spreadsheet Skills, create your own reusable Skills, mount files into sessions, and retrieve generated deliverables.
You will also see how agents can work with GitHub repositories and participate in development workflows.
Build agents that work toward outcomes
Many agent applications need something more precise than an open-ended conversation.
Claude Managed Agents can work toward a declared outcome and evaluate their work against a rubric. You will learn how to define what “done” means, interpret evaluation results, and allow an agent to revise its work until it satisfies the stated requirements.
Give agents persistent memory
A useful long-running agent may need information that extends beyond one context window or session.
You will build agents that store and retrieve relevant information over time while also considering versioning, read-only access, audit trails, and memory-poisoning risks.
Orchestrate multiple agents
Not every task should be assigned to a single general-purpose agent.
The course shows you how to coordinate agents with specialized responsibilities. One agent might conduct research, another might draft a report, and another might verify its accuracy.
You will learn when this approach is useful, when it adds unnecessary complexity, and how to route events and approvals within a multi-agent workflow.
Integrate agents into production systems
We also cover files, GitHub workflows, event streaming, webhooks, signature verification, idempotency, Slack notifications, model routing, and cost management.
The goal is to help you understand the larger system around the model, not just the model itself.
Fifteen hands-on labs
This is not a course built entirely around slides and conceptual demonstrations.
It contains 15 hands-on labs in which you build increasingly capable agents and supporting systems.
Among other projects, you will build:
- Your first managed agent using the Console
- A Python version of the agent using the SDK
- A research agent connected to Google Docs through MCP
- A reusable data-science environment
- A streaming console that displays tool use and running cost
- An agent that works with Linear through MCP
- A human approval checkpoint for potentially destructive commands
- A financial-analysis agent that generates spreadsheet deliverables
- An outcome-driven financial model generator
- A customer-support agent with persistent memory
- A multi-agent research, writing, and fact-checking pipeline
- An agent that edits code and opens a GitHub pull request
- A webhook integration that sends Slack notifications
Each lab introduces capabilities that feed into the final project.
The capstone: a personal research agent
The course concludes with a complete personal research-agent project.
This system brings together the major concepts from the course:
- Multiple coordinated agents
- Carefully designed system prompts
- A configured cloud environment
- MCP integrations and authenticated vaults
- Outcome evaluation
- Persistent memory
- Streaming progress
- Google Docs output
- Slack notifications
- Cost and scalability analysis
The result is not merely a chatbot that summarizes a prompt. It is an integrated agentic workflow designed to perform a useful task from beginning to end.
A foundation for Anthropic Claude certifications
The course is also relevant to learners building a broader learning path toward Anthropic Claude certifications.
It is not positioned as a collection of exam questions or a shortcut around the required knowledge. Instead, it gives you practical experience with many of the architectural and development concepts that Claude practitioners should understand.
That hands-on context can make certification material more concrete and useful.
Who should take this course?
The course is intended for:
- Software developers
- AI and machine-learning engineers
- Solutions architects
- Technical founders
- Cloud engineers
- Claude Code users
- Developers preparing to build agent-powered products
- Learners pursuing deeper expertise in the Anthropic ecosystem
You do not need previous experience with Claude Managed Agents. Some Python experience will be useful for the coding labs, but the course begins with the platform’s core concepts and setup process.
We also explain the different learning paths available to Python developers and Claude Code users.
About the instructors
Frank Kane
I have taught AI, machine learning, data engineering, and cloud computing to more than 1.2 million learners around the world.
I hold 26 patents in machine learning and spent nine years at Amazon as a senior engineer and senior manager.
My focus in this course is helping you understand the architecture behind managed agents and translating that architecture into practical development skills.
Puria Izady
Puria Izady is a former AWS Solutions Architect specializing in Generative AI and Machine Learning.
He is the creator of Pumping Code, where he teaches practical software and AI development, and the creator of Cocoduro, an agentic grocery solution.
Puria brings direct experience designing modern AI and cloud architectures and turning emerging AI capabilities into working applications.
Start building practical Claude agents
AI agents are becoming a major new layer of software development.
But there is a substantial difference between demonstrating an agent and building one that is observable, secure, integrated, cost-conscious, and capable of producing a reliable result.
Claude Managed Agents: In Depth and Hands On! is designed to help you close that gap.
For a limited time, enroll for $9.99 using the coupon below:
https://www.udemy.com/course/claude-managed-agents/?couponCode=CLAUDE-AGENTS
The introductory offer expires on July 25, 2026.
We hope to see you in the course.
