AI Red Teaming: Attacking LLM and Agentic Systems

[rlscorner]

AI Red Teaming: Attacking LLM and Agentic Systems
Last updated 10/2026
Created by Vasco Patrício
MP4 | Video: h264, 1920x1080 | Audio: AAC, 44.1 KHz, 2 Ch
Level: Expert | Genre: eLearning | Language: English + subtitle | Duration: 28 Lectures ( 3h 55m ) | Size: 3.5 GB

Red team LLM and agentic systems with threat modeling, prompt attacks, campaign scoring, and CI/CD testing

What you'll learn
⚡ AI security professionals and red teamers looking to assess vulnerabilities in LLM, RAG, and agentic systems.
⚡ Developers, tech leads, and architects responsible for building or securing LLM applications and AI agents.
⚡ Security, risk, and assurance professionals who need to prioritize, score, report, and track adversarial AI findings.
⚡ AI practitioners curious about prompt injection, jailbreaks, tool abuse, memory poisoning, and safe red team campaigns.

Requirements
❗ You don't need any prior AI red teaming knowledge. Familiarity with LLM applications, RAG, agents, or software security helps, but is NOT required.

Description

WHEN AI CAN ACT, A BAD OUTPUT IS ONLY THE BEGINNING
LLM applications do more than generate text. They retrieve content, call tools, retain memory, delegate work, communicate with other agents, and influence downstream systems.

Each capability creates new trust boundaries. Prompt injection can arrive through retrieved documents. A hijacked agent can misuse a legitimate tool. Poisoned memory can influence future sessions. Delegation can allow authority to travel farther than intended.

That means testing only direct prompts or model responses is not enough.

This course gives you a structured approach to AI red teaming across models, applications, tools, memory, agents, and shared state. You will learn how to identify attack paths, execute relevant attacks, evaluate outcomes, classify severity, and convert confirmed findings into repeatable regression tests.

The focus stays practical and defensive. You will examine how to run controlled campaigns in isolated, production-like environments without turning testing into a real incident.

MODULE WALKTHROUGH

Module 01: Foundations of LLM and Agentic Vulnerabilities
✨ You begin by building a shared language for LLM and agentic risk. You will use OWASP risk categories, distinguish model-level failures from system-level failures, and examine how tools, persistent memory, and inter-agent communication turn harmful outputs into harmful actions.

✨ You will also learn what AI red teaming includes: diverse adversarial inputs, escalating attack strategies, automated coverage, human creativity, scoring, severity-based triage, and clear limits.

Module 02: Threat Modeling and Attack Surfaces
✨ Next, you will map where attacks can enter and where harmful outcomes can occur. You will break down the trust boundaries around inputs, model generation, outputs, RAG, tools, planning, memory, delegation, and shared state.

✨ You will then prioritize targets using OWASP, MITRE ATLAS, likelihood, impact, ease of exploitation, and architectural trust boundaries. This creates a reasoned testing order rather than an unfocused list of attacks.

Module 03: Attack Techniques and Execution
✨ With the system mapped, you will examine how attackers manipulate prompts, conversations, training inputs, tools, agents, memory, and state.

✨ You will study direct and indirect prompt injection, jailbreak families, adversarial suffixes, obfuscation, crescendo attacks, data poisoning, backdoors, goal hijacking, unsafe affordance chaining, delegation laundering, consensus forcing, collusion, and memory poisoning.

✨ The module also covers defensive controls such as least privilege, message authentication, provenance, validation, consistency checks, state isolation, and versioning.

Module 04: Running and Scoring Red Team Campaigns
✨ Finally, you will turn individual tests into safe, repeatable campaigns. You will combine manual and automated testing in isolated, production-like environments using synthetic fixtures, mocked consequences, and stable inputs.

✨ You will learn to evaluate refusal robustness, false negatives, false positives, policy circumvention, Attack Success Rate, and finding severity. You will also validate model judges against human consensus and use deterministic checks or systems of record when outcomes can be verified directly.

✨ The course closes with CI/CD integration, scheduled scans, actionable disclosure, remediation verification, attack variants, and permanent regression tests.

LET ME TELL YOU... EVERYTHING
Some people - including me - love to know what they're getting in a package.

And by this, I mean, EVERYTHING that is in the package.

So, here is a list of everything that this course covers

✨ You will learn how the OWASP Top 10 for LLM Applications provides a shared taxonomy for vulnerabilities;

✨ You will learn to distinguish model-level failures from system-level failures and route remediation correctly;

✨ You'll learn about prompt injection, insecure output handling, sensitive information disclosure, excessive agency, and overreliance;

✨ You will learn how tools, APIs, code execution, and record changes turn manipulated outputs into consequential actions;

✨ You will learn how persistent memory allows poisoned information to influence future sessions;

✨ You will learn why inter-agent communication creates manipulation risks when agents trust peer outputs by default;

✨ You will learn how indirect prompt injection arrives through retrieved content and tool responses;

✨ You will learn why retrieved documents and tool outputs must be treated as untrusted inputs;

✨ You will learn how NIST, MITRE ATLAS, and OWASP define what to test before tools determine how to test it;

✨ You'll learn about PyRIT, garak, Promptfoo, DeepTeam, and Giskard as AI red teaming tools;

✨ You will learn to combine diverse adversarial inputs, escalating attacks, automation, expert creativity, and severity triage;

✨ You will learn to map attack points at LLM inputs, during model generation, and where outputs leave the system;

✨ You will learn how system prompts, user messages, and injected context combine trusted and untrusted content;

✨ You will learn how RAG adds an untrusted input channel through knowledge bases and retrieved documents;

✨ You will learn to validate and constrain generated code, SQL, links, markup, and downstream decisions;

✨ You will learn to threat model planning, tools, memory, delegation, and shared state across an agentic loop;

✨ You will learn why permissions must be checked at every hop in a delegation chain;

✨ You'll learn about authentication laundering, where routing through another agent makes a prohibited operation appear permissible;

✨ You will learn how shared mutable state expands blast radius and how isolated state limits interactions;

✨ You will learn to prioritize targets by likelihood, impact, ease of exploitation, and architectural trust boundaries;

✨ You will learn to use OWASP for risk coverage and MITRE ATLAS for realistic attacker tactics and techniques;

✨ You will learn why target rankings are hypotheses that should change when real attack results provide new evidence;

✨ You will learn how role-play, hypothetical scenarios, and gradual escalation disguise restricted requests;

✨ You'll learn about adversarial suffixes that use optimized strings to push models toward compliance;

✨ You will learn to test prohibited actions, data leakage, and task abandonment rather than checking only model wording;

✨ You will learn how encodings, substitutions, and translations can conceal malicious intent;

✨ You'll learn about crescendo attacks that build toward prohibited outcomes across individually harmless turns;

✨ You will learn why complete conversations must be evaluated when the unit of attack spans multiple messages;

✨ You will learn how training data poisoning can plant hidden behavior activated by a trigger phrase;

✨ You will learn why small fine-tuning datasets can amplify the influence of poisoned examples;

✨ You will learn to verify sources, pin versions, and test external models, datasets, model fileand dependencies;

✨ You will learn how goal hijacking redirects an agent from its intended objective;

✨ You will learn how legitimate tools can be used with attacker-chosen arguments or for illegitimate purposes;

✨ You'll learn about unsafe affordance chaining, where allowed tool calls combine into an unauthorized outcome;

✨ You will learn to classify tools as low-risk, medium-risk, high-risk, or forbidden for focused testing;

✨ You'll learn about consensus forcing, delegation laundering, and collusion in multi-agent systems;

✨ You will learn why agents should be authenticated and their messages validated against spoofing, alteration, and replay;

✨ You will learn to apply fan-out caps, depth limits, per-agent budgets, and explicit termination conditions;

✨ You will learn how memory poisoning can persist, spread across users, and influence downstream agents;

✨ You will learn how provenance distinguishes stale memory from poisoned memory;

✨ You will learn how versioning, validation before promotion, and consistency checkssupport detection and recovery;

✨ You will learn to run campaigns in a controlled purple environment shared by red and blue teams;

✨ You will learn to replicate representative production configurations while isolating real users and real data;

✨ You will learn to replace sensitive data with synthetic fixtures and snapshot non-deterministic inputs;

✨ You will learn to mock irreversible actions, external messages, money movement, and metered or credit-affecting calls;

✨ You will learn to measure refusal robustness across different attacks and formulations;

✨ You will learn to test false negatives, false positives, benign look-alikes, and policy circumvention;

✨ You will learn when rule-based scoring fits objective outcomes and when an LLM judge is needed for meaning;

✨ You will learn to validate attack scorers against independent human judgment and reviewer consensus;

✨ You will learn to sample clear successes, clear failures, and borderline outputs when testing a scorer;

✨ You will learn to reduce verbosity bias by requiring judges to cite specific evidence before scoring;

✨ You will learn to verify actions through deterministic checks and the system of record;

✨ You will learn how Attack Success Rate measures attack frequency but not finding severity;

✨ You will learn to classify severity using data sensitivity, reversibility, and blast radius;

✨ You will learn to define low, medium, high, and critical severity criteria before testing begins;

✨ You will learn to use adversarial testing as an automated CI/CD gate for risky releases;

✨ You will learn to regenerate and version adversarial test sets when prompts, tools, or guardrails change;

✨ You will learn to run scheduled scans for drift caused by model updates, data changes, and new attack techniques;

✨ You will learn why pipeline detection and runtime guardrails must work together;

✨ You will learn to document exact inputs, configurations, reproduction steps, boundaries, tools, and affected data;

✨ You will learn to rerun original attacks, test variants, and confirm legitimate behavior after remediation;

✨ You will learn to close findings with evidence and retain fixed attacks as permanent regression tests;

MY INVITATION TO YOU
Remember that you always have a 30-day money-back guarantee, so there is no risk for you.

Also, I suggest you make use of the free preview videos to make sure the course really is a fit. I don't want you to waste your money.

If you think this course is a fit and can take your knowledge to the next level... it would be a pleasure to have you as a student.

See on the other side!

Who this course is for
⭐ You will learn to identify, attack, evaluate, and reduce vulnerabilities in LLM and agentic systems through structured AI red teaming.
⭐ You will learn to classify model-level and system-level failures using OWASP, MITRE ATLAS, and agentic risk taxonomies.
⭐ You will learn to threat model LLM calls, RAG, agentic loops, tools, memory, delegation, shared state, and trust boundaries.
⭐ You will learn to test prompt injection, jailbreaks, obfuscation, data poisoning, goal hijacking, tool abuse, and agent attacks.
⭐ You will learn to run manual and automated campaigns in isolated, production-like sandboxes with repeatable synthetic fixtures.
⭐ You will learn to validate attack scorers, assess ASR and severity, integrate tests into CI/CD, and verify remediation.

Code:

https://nitroflare.com/view/6A196B376CC6AB1/AI_Red_Teaming_Attacking_LLM_and_Agentic_Systems.part1.rar
https://nitroflare.com/view/32193FA492C0891/AI_Red_Teaming_Attacking_LLM_and_Agentic_Systems.part2.rar
https://nitroflare.com/view/334DBAEB936C316/AI_Red_Teaming_Attacking_LLM_and_Agentic_Systems.part3.rar
https://nitroflare.com/view/C3FBD9D0F6DE184/AI_Red_Teaming_Attacking_LLM_and_Agentic_Systems.part4.rar

https://rapidgator.net/file/fae024875688a7b92191849aa3b131e9/AI_Red_Teaming_Attacking_LLM_and_Agentic_Systems.part1.rar.html
https://rapidgator.net/file/e58e7aeaa1e07034f7dc8f2d704a6742/AI_Red_Teaming_Attacking_LLM_and_Agentic_Systems.part2.rar.html
https://rapidgator.net/file/d693cf9269b36633f0a25db80d6f4de5/AI_Red_Teaming_Attacking_LLM_and_Agentic_Systems.part3.rar.html
https://rapidgator.net/file/ed66808025a7a871909ee76d38839852/AI_Red_Teaming_Attacking_LLM_and_Agentic_Systems.part4.rar.html