The 272,000-attack study: what a large-scale prompt injection competition found

TL;DR: A public red-teaming competition attracted 464 participants who submitted 272,000 indirect prompt injection attempts against 13 frontier models across three agent settings (arXiv:2603.15714, March 2026). Every model was vulnerable: attack success ranged from 0.5% to 8.5%. Universal attack strategies transferred across 21 of 41 behaviors and multiple model families, so per-model robustness gives a false sense of security. Three empirical lessons and five hardening steps follow from the data.
One percent sounds like nothing. Give an attacker 10,000 attempts against your agent and a 1% attack success rate means 100 successful injections. The largest public prompt injection competition published so far found attack success rates from 0.5% to 8.5% across 13 frontier models, and found that some attack strategies work across models.
That second finding is the one most teams aren’t accounting for.
What the competition measured and how
The competition ran for three weeks on the Gray Swan Arena platform with UK AISI and US CAISI, for a $40,000 prize pool. The paper’s authors include researchers from Gray Swan AI, UK AISI, US CAISI, OpenAI, Anthropic and Meta. 464 participants submitted 272,000 attack attempts; 8,648 succeeded, an overall rate of about 3.2%. Three agent settings were tested: tool calling, coding, and computer use, across 41 scenarios.
These aren’t attacks where a user types something malicious into a chat box. They’re indirect: adversarial instructions embedded in content the agent processes, such as emails, documents, code repositories and web pages. The agent reads the content, encounters the injected instruction, and follows it.
The scoring made concealment part of success. An attack counted only if the agent actually executed the harmful action (checked by a tool judge) and, in 34 of the 41 scenarios, the final response to the user gave no clue that anything had happened (checked by a prompt judge). Every success in those scenarios was, by construction, invisible to a user reading the agent’s answer.
The three findings that change how you defend
The first finding is about volume. Every model was vulnerable. Attack success rate here is successful attacks divided by attempts against that model:
| Model | Attack success rate | Successful / attempts |
|---|---|---|
| Gemini 2.5 Pro | 8.5% | 1,670 / 19,630 |
| Nova 1 Premier | 5.8% | 1,091 / 18,924 |
| SecAlign 70B | 5.5% | 618 / 11,238 |
| DeepSeek V3.1 | 5.4% | 808 / 15,026 |
| Kimi K2 (Thinking) | 4.8% | 589 / 12,299 |
| Nova 2 Lite | 4.7% | 672 / 14,244 |
| Qwen3 VL 235B | 4.2% | 781 / 18,733 |
| Grok 4 | 2.9% | 366 / 12,526 |
| GPT-5.1 | 2.5% | 202 / 8,096 |
| GPT-5 | 2.0% | 261 / 13,143 |
| Claude Haiku 4.5 | 1.3% | 177 / 13,696 |
| Claude Sonnet 4.5 | 1.0% | 136 / 13,603 |
| Claude Opus 4.5 | 0.5% | 61 / 11,969 |
The rates are per attempt, so they scale with how many tries an attacker gets. An agent that reads attacker-controllable content all day (inboxes, tickets, web pages) gives attackers many tries. At 0.5%, 10,000 attempts yield about 50 successes; at 8.5%, about 850. These are operational rates that require active defense, not periodic audits.
The second finding is the one most teams aren’t ready for: the authors identified universal attack strategies that transferred across 21 of 41 behaviors and multiple model families. An attacker who develops a working approach against any accessible model can expect some of it to carry over to a production deployment on a different provider. Transfer is not universal, though. The authors released 95 successful attacks against Qwen that did not transfer to any closed-source model.
The third finding: capability and robustness were only weakly correlated. Gemini 2.5 Pro scores near the top of capability benchmarks and had the highest attack success rate in this competition. You cannot pick the “most capable” model and assume you’re picking the most resilient one. Robustness has to be measured on its own.
What “transferable attacks” means for defense
Most organizations currently defend against prompt injection at the model level: they pick a model they consider robust, tune its system prompt, and trust that the model’s training makes it harder to manipulate. The competition data breaks this assumption.
When attack strategies transfer across model families, the question stops being “is this model robust?” and becomes “does our system have layers that catch injections the model doesn’t?” The model is one control, not the control. The underlying reason, that instructions and data share one channel, is covered in prompt injection is a structural attack.
The concealment requirement compounds this. When an agent executes an injected instruction silently (forwarding data, triggering a tool call, modifying a file), there’s no output the user can flag as suspicious. Detection at the action level, not just prevention, is a first-class requirement.
graph TD
A[External content enters agent context] --> B{Input scanning}
B -->|Flagged| C[Block / sanitize]
B -->|Passes| D[Model processes content]
D --> E{Output monitoring}
E -->|Anomaly detected| F[Alert / interrupt]
E -->|Passes| G{Action sandbox}
G -->|High-risk action| H[Require human approval]
G -->|Low-risk action| I[Execute with audit log]
style C fill:#d4edda
style F fill:#fff3cd
style H fill:#fff3cd
style I fill:#d1ecf1
The diagram above shows what defense-in-depth looks like for an agent pipeline. The model is in the middle: it’s one node, not the whole graph. Input scanning and output monitoring sit on either side. Actions are sandboxed by risk level. Logs exist everywhere. None of these layers is reliable by itself. All of them together make the attacker’s job substantially harder. Architecting secure AI agents goes deeper on the runtime layers.
Five concrete hardening steps derived from the competition data
The organizers open-sourced the competition environment, shared model-specific attack data with the frontier labs, and gave the full dataset to UK AISI and US CAISI. The five steps below map to the patterns the paper reports.
First: scan external content before it enters agent context. The successful attacks in the competition came through content the agent was processing: documents, emails, tool outputs. A lightweight classifier checking that content against known injection patterns won’t catch everything (detectors are easy to evade), but it raises the cost of commodity attacks.
Second: structurally separate instruction channels from data channels. Prompt injection works because language models receive instructions and data in the same token stream and must guess which is which. System-level prompts, user prompts, and external content should be differentiated wherever the model’s context format allows. Several model providers now support distinct content roles in their APIs. Use them.
Third: scope agent tool permissions to the minimum the task actually requires. This matters because of the concealment finding. An agent with write access to a file system, email client, and external APIs can do real damage from a single successful injection, without the user ever seeing a suspicious response. An agent scoped to read-only operations on specific resources can’t. Least privilege applies to tool grants the same way it applies to service accounts.
Fourth: monitor for behavioral anomalies at the action level, not just in model output. Output monitoring catches the attacks that show up in what the user sees. The competition’s successful attacks were required not to. Log every tool call the agent makes, every file it reads or writes, every external request it sends. Build detection on those action logs. That’s where the quiet attacks live.
Fifth: test your specific deployment, not a generic benchmark. The open-sourced competition environment is a starting point, but the rate that matters is not the average across 13 models in controlled conditions. It is the rate against your agent, your tool grants, your document corpus and your system prompt. Red-teaming is not a pre-launch checklist item. It’s an ongoing operation; the red-team playbook covers how to run it.
FAQ
What is the attack success rate for prompt injection across models? The competition found rates ranging from 0.5% (Claude Opus 4.5) to 8.5% (Gemini 2.5 Pro) across 13 frontier models, with 8,648 successful attacks out of 272,000 attempts.
What does “universal attack transfer” mean in practice? The paper identified attack strategies that worked across 21 of 41 scenario behaviors and multiple model families. An attacker can develop a strategy on a model they can access and expect some of it to work against a different provider. Not everything transfers: 95 attacks that worked on Qwen transferred to no closed-source model.
Which model was most resistant to prompt injection in the competition? Claude Opus 4.5 had the lowest attack success rate at 0.5%. However, 0.5% is not zero: an attacker with 10,000 attempts should expect about 50 successes.
Does a capable model tend to be more robust against prompt injection? Not reliably. The competition found a weak correlation between capability and robustness. Gemini 2.5 Pro ranked high on capability benchmarks but had the highest attack success rate (8.5%) in the competition.
What three agent settings did the competition test? Tool calling, coding, and computer use.
Related posts on prompt injection: the structural argument, indirect injection through your data, why detection is broken, the defense stack and runtime enforcement with ClawGuard. For agent-side defense patterns, see Prompt injection defense for AI agents and Ethical AI agents and safety.
Source paper: How Vulnerable Are AI Agents to Indirect Prompt Injections? Insights from a Large-Scale Public Competition (Dziemian et al., arXiv:2603.15714, March 2026)