Trusted by 12,500+ Learners
Certified Agentic AI Security Expert (CAASE)
Certified Agentic AI Security Expert (CAASE) is a hands-on Agentic AI Certification for professionals who secure AI agents. You learn to attack and defend agent reasoning, memory, and tool use across 7 chapters. The course covers prompt injection, memory poisoning, multi-agent identity, and agent communication protocols like A2A and UCP. You get 60 days of lab access and 30+ guided exercises. The exam gives you 5 practical challenges in 6 hours. You need 80% to pass. Become an Agentic AI Security Expert within 60 days.
Trusted by top companies across industries, empowering thousands of professionals worldwide. Join the ranks of security leaders
Course Chapters
“Here’s exactly what you’ll master in 7 hands-on chapters:”
Course Pre-requisites
- Course participants should have knowledge of running basic Linux commands like ls, cd, mkdir, etc.,
- Familiarity with any scripting language like Python, Golang, or ruby helps. However, it’s not a necessity.
- It is recommended to have completed the Certified AI Security Professional (CAISP) course from Practical DevSecOps.
Chapter 1: Introduction To MCP and The Agentic Ecosystem
- About the course, syllabus, and how to approach it
- About the CAASE Certification and how to approach it
- Course Lab Environment
- Lifetime course support 24 x 7
- What Makes an “Agent” Different from an LLM Call
- The plan to act to observe (cognitive) loop
- Agents vs. chatbots vs. copilots vs. autonomous agents
- Planner-Executor-Verifier and other common agent design patterns
- Single-agent vs. multi-agent systems
- Anatomy of an Agent Harness
- What a “harness” actually wraps around a model
- Real-world harnesses [Herms, OpenClaw Ecosystem, and more]
- Agent runtimes vs. MCP servers vs. the underlying LLM
- Building your own minimal agent harness
- The Agentic AI Attack Surface
- Mapping a complete agentic pipeline
- The agentic layer after the model and MCP tools
- Trust boundaries in an agentic system
- Threat Modeling and Risk Frameworks for Agentic AI
- OWASP Top 10 for LLM Applications
- OWASP Agentic Security Initiative
- MITRE ATLAS matrix for AI/ML systems
- NIST AI Risk Management Framework (AI RMF)
- NIST AI 100-2 adversarial ML taxonomy
- Rating agentic-specific risks
- The Free/Open Agentic Toolchain
- Local open-weight models sized to fit consumer-grade VRAM budgets
- Cloud/API-routed models for tasks that exceed local hardware capacity
- OpenRouter-style routing layers across free and paid models
- VSCode as an agent surface (extensions, integrated coding agents)
- Hands-on Exercise:
- Learn how to use our browser-based lab environment
- Building a Minimal Agent Harness on Top of a Local Open-Weight Model
- Setting Up LibreChat for MCP Tool-Calling with a Local Model
- Standing Up Hermes Agent with a Local and a Cloud-Routed Model Side by Side
- Routing Agent Requests to a Large Cloud Model via a Proxy and Comparing It to a Local Model
- Comparing Tool-Calling Determinism Across Two Local Models Running Concurrently
- Threat Modeling an Agentic AI System Using MITRE ATLAS
Chapter 2: Attacking and Defending Agent Reasoning, Goals, and Prompt Boundaries
- Input and Output Boundary Enforcement
- Where untrusted input enters an agent’s reasoning loop
- What an agent is allowed to emit, trigger, or act on
- The Prompt Injection Taxonomy for Agents
- Direct vs. indirect prompt injection
- Chained and multi-hop injection across tool outputs
- Multi-language and encoding-based injection
- Refusal suppression and instruction-override techniques
- Attacking the Reasoning Loop
- Jailbreaking an agent vs. jailbreaking a model
- Prompt leaking of system instructions, goals, and hidden context
- Goal hijacking and objective substitution
- Agent hijacking: redirecting an autonomous task mid-execution
- Defending Agent Goals and Reasoning
- Secure agent development patterns
- Constrained planning
- Structured output enforcement
- Guardrail frameworks and policy layers around the reasoning loop
- Goal-integrity checks and objective-drift detection
- Designing agents that fail safely when reasoning is compromised
- Secure agent development patterns
- Hands-on Exercises:
- Prompt Injecting an Agent’s Planning Loop via a Tool Response
- Jailbreaking a Local Agent’s Underlying Model
- Leaking an Agent’s System Prompt and Hidden Objectives
- Hijacking an Agent’s Goal Mid-Task
- Adding a Guardrail Model to Filter Agent Input/Output
- Detecting Objective Drift Through Structured Output Validation
Chapter 3: Attacking and Defending Agent Memory, Context, and Tool Use
- Agent Memory and Context Stores
- Short-term memory vs. long-term/persistent memory
- Context window management and context injection points
- RAG pipelines as an agent memory source
- Attacking Memory and Context
- Memory poisoning and long-term malicious persistence
- Cross-session and cross-user context bleed
- Poisoning retrieval sources to influence future agent behavior
- Attacking Tool and Function-Calling Interfaces
- Function-calling abuse and parameter injection
- Chaining tool calls to escalate privileges
- Malicious open-weight models as a tool-use risk
- Defending Memory, Context, and Tool Use
- Tool-execution sandboxing and output validation
- MCP-level data integrity checks
- Least-privilege tool scoping and allow-listing
- Detecting a compromised agent after the fact
- Hands-on Exercises:
- Poisoning an Agent’s Long-Term Memory Store
- Poisoning a RAG Source to Influence Future Agent Responses
- Abusing Function-Calling Parameters via LibreChat’s MCP Tools
- Chaining Tool Calls to Escalate an Agent’s Effective Privilege
- Sandboxing Tool Execution Using Docker
- Auditing Hermes Agent’s MCP Server Connections for Data Integrity
- Reconstructing a Compromised Agent Session from Memory Artifacts
Chapter 4: Attacking and Defending Computer-Use, Browser, and Coding Agents
- The Coding and Computer-Use Agent Landscape
- Coding agents: OpenCode and comparable CLI-based coding agents
- The OpenClaw ecosystem
- OpenClaw
- NanoClaw, MiniClaw, SecureClaw, NemoClaw
- ClawHub skill marketplace
- VSCode-integrated agent extensions
- Browser-driving
- computer-use agents
- How agents perceive and act on a screen/DOM
- Attacking Coding Agents
- Prompt injection via various sources
- Supply-chain injection through packages or marketplace skills
- Escaping the intended repository/workspace scope
- Abusing agent-granted shell, filesystem, or network access
- Case study: OpenClaw’s documented exposed-gateway and malicious-skill incidents
- Attacking Browser and Computer-Use Agents
- Malicious page content as an indirect prompt-injection vector
- Clickjacking and UI-manipulation attacks against visual/DOM-parsing agents
- Credential and session exposure through agent-driven browsing
- Defending Computer-Use and Coding Agents
- Workspace and filesystem sandboxing
- Container isolation as a security model
- Hardened forks vs. application-level permissions
- Egress control and network allow-listing for agent processes
- Human-approval checkpoints for destructive or irreversible actions
- Auditing and hardening a harness with a purpose-built security plugin
- Hands-on Exercises:
- Standing Up OpenClaw and Reproducing a Documented Misconfiguration
- Prompt Injecting a Coding Agent via a Malicious README and Commit Message
- Auditing and Hardening an Agent Harness Using a Security Audit Plugin
- Comparing Workspace Escape Resistance Across Standard vs. Container-Isolated Agent Runtimes
- Deploying a Small-Model-Friendly Secure Harness
- Vetting a Marketplace Skill Before Installation
- Attacking a Browser/Computer-Use Agent via Malicious Page Content
- Enforcing Human-Approval Checkpoints for Destructive Agent Actions
Chapter 5: Assessing and Securing Multi-Agent Systems and Agent Identity
- Multi-Agent Architectures and Topologies
- Orchestrator/sub-agent and swarm topologies
- Agent-to-agent (A2A) communication protocols
- Delegation Chains and Task Hand-off Between Agents
- Protocol and Data Risks
- A2A protocol abuse and message spoofing
- Cross-agent and cross-tenant data leakage
- Collusion and Confused Deputies
- Collusion and cascading failure across an agent swarm
- Confused-deputy scenarios when agents delegate authority
- Agent Identity and Access
- Establishing identity for non-human/autonomous actors
- Delegated authorization and token scoping between agents
- Least-privilege and least-agency permission design
- Oversight, Containment, and Fail-Safes
- Human-in-the-loop vs. human-on-the-loop checkpoints
- Detecting, containing, and safely terminating a rogue agent
- Fail-safe design for high-consequence or physical-world-acting agents
- Hands-on Exercises:
- Orchestrating a Local and Cloud-Routed Agent Pair in a Delegator/Worker Setup
- Delegating Subtasks to Isolated Subagents Using Hermes Agent
- Spoofing Agent-to-Agent Messages to Manipulate a Delegated Task
- Exploiting a Confused-Deputy Chain Across Delegated Agents
- Scoping and Testing Delegated Authorization Tokens Between Agents
- Detecting and Safely Terminating a Rogue Agent
- Adding a Human-in-the-Loop Approval Gate to a Multi-Agent Workflow
Chapter 6: Operationalizing Agentic AI Security
- SAST/DAST and Testing Gates for Agentic Pipelines
- SAST/DAST adapted for agent code and harness configurations
- Red-teaming and adversarial testing gates before agent release
- CI/CD Integration for Agentic Security
- Observability and Anomaly Detection for Agent Behavior
- Observability for autonomous decision-making
- Anomaly detection for agent behavior drift
- Agentic AI for Defensive SecOps
- Vetting Third-Party Harnesses, Models, and Marketplaces
- Vetting third-party harnesses, orchestration frameworks, and open/free models
- Vetting community skill/plugin marketplaces before installation
- AI/Agent Bill of Materials and Provenance Tracking
- Governance, Compliance, and Emerging Frontiers
- NIST AI RMF and OWASP Agentic Security Initiative controls in practice
- Zero Trust patterns applied to autonomous agents
- EU AI Act and comparable frameworks for autonomous systems
- Confidential computing and attestation for agent execution
- CISA Five Eyes Agentic AI Security Guidance
- Hands-on Exercises:
- Gating Agent Releases with a Red-Team Test Suite in CI/CD
- Building an Observability Dashboard for Agent Reasoning Traces
- Generating an AI/Agent Bill of Materials (AIBOM) for a Harness
- Vetting an Open-Weight Model’s Provenance Before Routing Production Traffic to It
- Signing and Verifying an Agent Harness Using Cosign
- Scanning Marketplace Skills for Supply-Chain Risk
- Building a Defensive SecOps Agent for Alert Triage
Chapter 7: Threat Modeling Agentic AI Systems and Agent Communication Protocols
- Threat Modeling Fundamentals for Agentic AI
- Structured threat modeling for agents
- Applying MITRE ATLAS and the OWASP Agentic Security Initiative across a full agent deployment
- Trust Boundaries and Risk Scoring for Agentic Systems
- Mapping trust boundaries across single-agent, multi-agent, and cross-organization topologies
- Scoring agentic-specific risks
- Agent Communication Protocols: A2A, ACP, and UCP
- Agent-to-Agent (A2A) protocol
- Message structure
- Capability discovery
- Task delegation
- Agent Communication Protocol (ACP)
- Session and state management between heterogeneous agents
- Unified Context Protocol (UCP):
- Shared context exchange across agents and orchestrators
- Comparing trust and authentication models across A2A, ACP, and UCP
- Intersection and divergence from MCP’s tool-layer trust model
- Agent-to-Agent (A2A) protocol
- Attacking Agent Communication Protocols
- Message spoofing and identity forgery across A2A, ACP, and UCP
- Capability-discovery abuse
- Context and state injection through shared UCP context stores
- Replay, downgrade, and man-in-the-middle attacks against inter-agent sessions
- Cross-protocol confusion attacks when an orchestrator bridges multiple protocols
- Defending and Governing Agent Communication Protocols
- Mutual authentication and message signing across A2A, ACP, and UCP
- Schema validation and capability allow-listing at the protocol boundary
- Session integrity, replay protection, and secure context-store design
- Threat-model-driven controls
- Emerging governance and interoperability standards for agent communication protocols
- Hands-on Exercises:
- Threat Modeling a Multi-Agent Deployment Using STRIDE and MITRE ATLAS
- Standing Up an A2A Message Exchange Between Two Local Agents
- Spoofing Agent Identity Over A2A to Hijack a Delegated Task
- Abusing ACP Session State to Escalate Privilege Between Agents
- Poisoning a Shared UCP Context Store to Influence Downstream Agents
- Auditing a Cross-Protocol Orchestrator Bridging MCP, A2A, and UCP
- Implementing Mutual Authentication and Message Signing Across A2A/ACP/UCP
- Building a Protocol-Level Threat Model and Control Set from Scratch
Senior AI & Agentic Security Architect
Principal Application Security Engineer
Applied AI Security Engineer
Staff Information Security Engineer
Penetration Testers
Proof > Promises. Certifications Hiring Managers Trust
Career Outlook
What can I do with the Certified Agentic AI Security Expert Course?
With CAASE, you can attack and defend an agent’s reasoning loop, detect memory and RAG poisoning, harden tool-calling interfaces, and secure multi-agent identity and communication across A2A, ACP, and UCP. You leave with skills you apply on day one, on systems that are already in production.
Who should take the Certified Agentic AI Security Expert Course?
AI agents already act on real systems with real credentials. These are the roles responsible for keeping that safe
Senior AI & Agentic Security Architect
Agents chain tool calls through delegated agents. Your usual trust diagrams miss that path. Learn it, and you become the architect teams call before launch, not after the breach.
Principal Application Security Engineer
Your SAST rules assume humans wrote the code. Agents write and run their own. Learn to sandbox tool execution and catch function-calling abuse. Own that answer instead of guessing.
Applied AI Security Engineer
You secure the model layer daily: prompt injection, jailbreaks, adversarial inputs. Agents add memory, tools, and goals attackers can hijack. Learn that layer, and you secure what models do.
Staff Information Security Engineer
Engineers bring you questions nobody else can answer. Agentic governance is next. Learn NIST AI RMF and build an AI bill of materials. Write the standard others follow.
Penetration Testers
Your last engagements mapped APIs blindly. The next might be an agent planning its own steps. Learn that chain, and you set the rate instead of following it.
88%
Of organizations confirmed or suspected an AI agent security incident in the past 12 months. Healthcare hit 92.7 percent. Financial services hit 54.7 percent. From Gravitee’s State of AI Agent Security 2026 Report, a survey of 750 executives.
$293k+
Top 10 percent base pay for an AI Security Engineer in the US in 2026, per Glassdoor. Specialists who add agentic red teaming or multi-agent security skills command 20 to 30 percent more on top of standard AI security pay, per infosec.qa’s 2026 salary data.
Understanding the above numbers
These figures come from Gravitee’s 2026 executive survey, Glassdoor’s crowdsourced salary data, and infosec.qa’s 2026 salary guide. Actual pay depends on your experience, location, and employer. We provide the training. The results are yours to build.
What you’ll learn from the
Certified Agentic AI Security Expert Course?
Understanding the Agentic AI Architecture
- Learn how an agent harness wraps a model
- Explore the plan, act, and observe loop
- Map trust boundaries across the agent pipeline
Attacking Agent Reasoning and Prompt Boundaries
- Learn the prompt injection taxonomy for agents
- Jailbreak an agent's reasoning loop, not just the model
- Hijack an agent's goal mid-task
Attacking Agent Memory, Context, and Tool Use
- Poison an agent's long-term memory store
- Poison a RAG source to influence future answers
- Chain tool calls to escalate agent privilege
Securing Coding, Browser, and Computer-Use Agents
- Escape a coding agent's intended workspace
- Sandbox tool execution with container isolation
- Vet a marketplace skill before you install it
Multi-Agent Systems and Agent Identity
- Spoof agent-to-agent messages to hijack a task
- Exploit confused deputy chains between delegated agents
- Scope delegated authorization tokens between agents
Operationalizing Agentic AI Security, Risk, and Governance
- Threat model a deployment with MITRE ATLAS
- Build an AI agent bill of materials
- Apply NIST AI RMF and the EU AI Act
We have provided training and presented at numerous industry events.
Hear from our learners
We’re proud to be working with these incredible Security Engineers, and thankful for their feedback, suggestions, and support.
Frequently asked questions
What is the Certified Agentic AI Security Expert (CAASE) course?
Certified Agentic AI Security Expert (CAASE) is a hands-on, offense-and-defense training course from Practical DevSecOps that teaches security professionals how to attack and defend agentic AI systems: AI agents that plan, remember, call tools, browse the web, write and execute code, and delegate tasks to other agents. The course covers agent harness architecture, prompt injection and reasoning-loop attacks, memory/RAG poisoning, tool-calling abuse, coding and computer-use agent security, multi-agent identity and delegation risks, and how to operationalize agentic security across DevSecOps and governance frameworks like the NIST AI RMF and OWASP Agentic Security Initiative.
Who should take the Certified Agentic AI Security Expert (CAASE) course?
Certified Agentic AI Security Expert (CAASE) is designed for security professionals who already work in offensive or defensive security roles and want to specialize in AI agent security, specifically penetration testers, red teamers, cloud security professionals, application security engineers, IT security managers, and DevOps engineers. The course is rated Intermediate to Advanced, so it assumes an existing security background rather than teaching security fundamentals from scratch.
What are the prerequisites for Certified Agentic AI Security Expert (CAASE)?
Students should be comfortable with basic Linux commands (such as ls, cd, and mkdir), and familiarity with a scripting language like Python, Golang, or Ruby is helpful but not required. Practical DevSecOps also recommends completing its Certified AI Security Professional (CAISP) course beforehand, since CAASE builds on foundational AI security concepts.
How long does the Certified Agentic AI Security Expert (CAASE) course take to complete?
The course content totals 40 hours: 8 hours of video lectures and 32 hours of hands-on labs, and it can be taken as a 3-day instructor-led training or as 36 hours of self-paced training. Enrolled students get 3 years of access to the on-demand course material, along with 60 days of access to the live online lab environment.
What topics does the Certified Agentic AI Security Expert (CAASE) syllabus cover?
The CAASE course is organized into seven chapters:
- The agentic AI architecture, threat landscape, and toolchain;
- Attacking and defending agent reasoning, goals, and prompt boundaries;
- Attacking and defending agent memory, context, and tool use;
- Attacking and defending computer-use, browser, and coding agents;
- Assessing and securing multi-agent systems and agent identity;
- Operationalizing agentic AI security across DevSecOps, governance, and the supply chain; and
- Threat modeling agentic AI systems and agent communication protocols (A2A, ACP, and UCP).
What hands-on labs are included in Certified Agentic AI Security Expert (CAASE)?
CAASE includes more than 30 guided exercises, such as building a minimal agent harness, prompt-injecting an agent’s planning loop through a tool response, poisoning an agent’s long-term memory or RAG source, chaining tool calls to escalate privilege, escaping a coding agent’s workspace sandbox, spoofing agent-to-agent messages to hijack a delegated task, generating an AI/Agent Bill of Materials (AIBOM), and signing a harness with Cosign. All labs run in a browser-based lab environment accessible from a laptop, desktop, or even a tablet.
How does the Certified Agentic AI Security Expert (CAASE) certification exam work?
The CAASE exam is a 6-hour, task-based practical exam (not a multiple-choice test) in which candidates solve five hands-on challenges that mirror the attack-and-defense scenarios covered in the course, such as exploiting agentic AI weaknesses and using automated tools against them. After finishing the exam, candidates have 24 hours to submit a written exam report for evaluation.
What score is needed to pass the CAASE exam?
Candidates need to score at least 80 out of 100 points (80%) across the exam’s five challenges to earn the CAASE certification. Points are awarded based on how complete each challenge solution is, and each student receives one exam attempt as part of the course enrollment.
What will I receive when I enroll in the CAASE course?
How is Certified Agentic AI Security Expert (CAASE) course is different from a general AI security or prompt-injection course?
CAASE focuses specifically on the agentic layer: the harness, planning loop, memory store, and tool-calling logic that sit on top of a model, rather than attacking the underlying LLM itself. It goes beyond single-turn prompt injection to cover multi-agent delegation abuse, confused-deputy attacks between agents, computer-use and coding-agent workspace escapes, agent-to-agent protocol attacks (A2A, ACP, UCP); and supply-chain risks from open-weight models and marketplace skills, topics that generic LLM security courses typically don’t address.
Unmatched practical focus
70% hands-on labs for mastering real-world scenarios.
Expert-crafted curriculum
Get real-world insights from experienced security experts.
Practical exam
Take a 6-hour examination to show what you have learned.
24/7 expert support
Prepare for the Agentic AI Attack Surface Before It Hits Your Systems
The Certified Agentic AI Security Expert course gives you job-ready skills to secure AI agents that plan, remember, and act on their own. Pass the 6-hour practical exam and prove you can attack and defend agentic systems end-to-end.












