WAAA! Web Adversaries Against Web Agents
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: We're looking at the paper: "WAAA! Web Adversaries Against Web Agents".
Elias: Here's the gist of the paper. Large language models (LLMs) are increasingly being integrated into web browsers to create agentic browsing systems that execute actions behalf of the user.
Nadia: This paper proposes the first web-focused threat model for agentic browsers and uses it to derive a taxonomy of 20 attacks across both the web and LLM space.
Elias: The Core Problem Identified The authors argue that prior work on agentic browser attacks focuses exclusively on indirect prompt-injection attacks, failing to consider traditional web social engineering attacks originally designed to trick humans.
Nadia: The key insight is that the LLM agent in an agentic browser is a confused deputy unable to distinguish task steps from traditional web attacks.
Title and authors: Nadia: So we've talked about what the paper is calling "WAAA! Web Adversaries Against Web Agents" and how it sets up a framework for understanding these threats. We also touched on the broad scope of agentic browsers being analyzed.
Elias: Right. To get into the nitty-gritty, let's look at how they define this threat model itself and what its structure is supposed to achieve for defense researchers.
Priya: I’m thinking about how this framework helps us move past just looking at single attack types and start seeing the bigger picture of a system's vulnerabilities.
Nadia: They combine existing agentic models with traditional browser security, using two main dimensions: browser properties like capabilities and input data, versus attacker properties like capabilities and target.
Elias: That structure lets them categorize attacks based on what the agent is *given* versus what the attacker *wants* to achieve.
Priya: So if we look at the taxonomy of twenty attacks they derive, how does that structure help us figure out where to focus our testing efforts <ref:2605.05509#pg1>?
Nadia: It helps because it shows how attacks depend on both the capabilities provided to the agent and what the attacker is aiming for.
Elias: And they show that their attacks reproduce across four major LLM models from different vendors in a generalizability study on fourteen of them <ref:2605.05509#pg2,a generalizability study on 14 of>.
Priya: That reproducibility across models is a strong signal, it suggests these are fundamental issues with the architecture rather than just quirks of one specific AI implementation.
Nadia: Right, and they distill their findings into five major failure modes that apply to both traditional and LLM web threats: agents bridging cross-site data, same-site data, hallucinating URLs, websites attacking the LLM itself, and misusing integrated tools.
Elias: And they show these five failure modes manifest even when facing traditional web attacks.
Priya: That’s a lot of ground to cover in terms of defense strategy if you’re trying to secure this space.
Nadia: The implication is that we need to move away from retrofitting safety and toward rearchitecting the browser security model itself to align with this specific threat taxonomy.
The paper's summary: Elias: So, building on what we said, let’s unpack the core summary of "WAAA! Web Adversaries Against Web Agents." What is the fundamental problem they identified in their research?
Nadia: They found that prior work has been too narrow, focusing only on indirect prompt-injection attacks. This leaves a big blind spot for traditional web social engineering attacks aimed at tricking humans directly.
Priya: So, the authors are saying that we're missing the human-centric part of the attack surface when we look at agentic systems?
Elias: Precisely, they argue that the LLM agent is a confused deputy incapable of distinguishing between its required task steps and these older, traditional web attacks.
Nadia: They take the original See→Act model and expand it to include every component of a browser—the rendering engine, the agent reasoning, all those pieces.
Priya: If you're modeling an entire system like that, what does that actually mean for understanding how data flows?
Elias: It means they are accounting for more than just the LLM's output; they’re looking at how the browser interacts with the page and its tools.
Nadia: They propose this new web-focused threat model specifically to map out these broader attack vectors systematically using that See→Act foundation.
Priya: So, when you look at their twenty attacks, what's the main takeaway about how these attacks are structured <ref:2605.05509#pg1>?
Elias: The structure itself is key; it shows that the success of an attack depends heavily on the specific capabilities handed to the agent and what resources an attacker has available.
Nadia: It’s not just about a single exploit code; it's about mapping out dependencies across those four property dimensions they defined.
The paper's improvements: Nadia: Now that we know what the problem is, the authors suggest specific improvements for how we should approach defending these systems based on their threat model.
Elias: They argue that meaningful protection requires a rearchitecture of agentic browsers around this new security model instead of just patching existing designs.
Priya: So, what kind of architectural changes are they suggesting? Are we talking about adding more filters or changing the core design philosophy?
Nadia: They suggest limiting capabilities to the absolute minimum required for a specific workflow to drastically reduce the attack surface.
Elias: That’s a practical constraint; if an agent doesn't need access to, say, general browser UI functionality, it shouldn't have it by default.
Priya: That ties back into my earlier point about trust—they suggest enabling developers to annotate web content with trust levels on the site itself.
Nadia: Right. This addresses the problem where there’s no clear notion of trust within content on the same site, letting the agent make more informed decisions about what to be cautious of.
Elias: They also propose using static or semi-static rules that reflect those common failure modes to intervene when actions would break established boundaries.
Priya: So, it’s a mix of architectural limits, content trust signals, and runtime rule enforcement all at once.
Conclusion: Nadia: To wrap up this discussion on "WAAA! Web Adversaries Against Web Agents," the authors conclude that agentic browsers need to be rearchitected before they can handle the current web environment effectively.
Elias: They summarize that all twenty attacks studied result in those same five failure modes, which means fixing one type of attack won't solve the whole problem <ref:2605.05509#pg1>.
Priya: So, if you had to distill this for someone just listening to the show who doesn't read research papers, what’s the single most important thing they want you to know?
Nadia: The core contribution is establishing an expert-guided taxonomy of attacks against agentic browsers that gives us a foundation for future work.
Elias: It’s providing that map, showing exactly where the security gaps are and what kind of defenses are needed based on their threat model.
Priya: It’s a necessary step to move from just hoping the models align well to actually building systems that are resilient against real-world manipulation.
North Carolina State University
cs.CR
Submitted: 2026-05-06
Updated: 2026-10-29
Code: https://github.com/microsoft/playwright-mcp
Project page: https://www.theregister.com/2024/06/25/polyfillio_china_crisis
License: http://creativecommons.org/licenses/by-nc-nd/4.0/
Importance score: 86/100
The gist: Large language models (LLMs) are increasingly being integrated into web browsers to create agentic browsing systems that execute actions behalf of the user.
Key concepts
- Confused Deputy Model
- This concept views the LLM agent in an agentic browser as a 'confused deputy.' Because the agent struggles to distinguish between its assigned task steps and standard web attacks, it can be tricked into performing unintended actions that violate security boundaries.
- Browser Properties and Attacker Properties
- The threat model structures security risks by looking at two main dimensions: what the browser itself offers (Capabilities and Input Data) and what the attacker possesses (Capabilities and Target). This framework helps map how specific browser features can be exploited by different types of malicious actors.
- Failure Modes
- The study distills complex threats into five broad failure modes that agentic browsers exhibit when facing web threats. These include agents bridging data across sites, hallucinating URLs, and misusing integrated tools. Understanding these common outcomes is crucial for designing effective defenses.
- Taxonomy of Attacks
- The paper develops a structured list of 20 attacks categorized by four dimensions: Browser Properties, Attacker Properties, Browser Capabilities, Input Data, Attacker Capabilities, and Attacker Target. This taxonomy provides an expert-guided map for understanding the entire attack surface.
Terminology
Summary
Large language models (LLMs) are increasingly being integrated into web browsers to create agentic browsing systems that execute actions behalf of the user. p. 0 edu
Alexandros Kapravelos
North Carolina State University
Raleigh, North Carolina, USA
akaprav@ncsu. edu
Abstract
Large language models (LLMs) are increasingly being integrated
into web browsers to create agentic browsing systems that execute
actions behalf of the user. However, by failing to consider traditional web attacks,
previous agentic browser threat models have a blind spot to web
social engineering attacks originally designed to trick humans. In this paper, we propose the first web-focused threat model for
agentic browsers and use it to derive a taxonomy of 20 attacks
across both the web and LLM space and implement 18 for the
attacks.Where the paper says it
Where the paper says it
The Core Problem Identified
The authors argue that prior work on agentic browser attacks focuses exclusively on indirect prompt-injection attacks, failing to consider traditional web social engineering attacks originally designed to trick humans. The key insight is that the LLM agent in an agentic browser is a confused deputy unable to distinguish task steps from traditional web attacks. p. 0 In this paper, we propose the first web-focused threat model for
agentic browsers and use it to derive a taxonomy of 20 attacks
across both the web and LLM space and implement 18 for the
attacks. Our threat model extends the original See→Act browser
agent model to account for all components of a browser, and frames
the agent as a confused deputy unable to distinguish task steps
from traditional web attacks. In this paper, we propose the first web-focused threat model for
agentic browsers and use it to derive a taxonomy of 20 attacks
across both the web and LLM space and implement 18 for the
attacks. Our threat model extends the original See→Act browser
agent model to account for all components of a browser, and frames
the agent as a confused deputy unable to distinguish task steps
from traditional web attacks.Where the paper says it
Where the paper says it
The Proposed Threat Model
The authors propose a new web-focused threat model that combines existing agentic browser threat models (based on the See→Act model [56]) with traditional browser security models (i.e., Chromium security model [22] and the web attacker model [21]). p. 0 We accomplish this by
proposing a new web-focused threat model that combines existing
agentic browser threat models (based on the See→Act model [56])
with traditional browser security models (i. , Chromium security
model [22] and the web attacker model [21]). The web page provides the attacker-controlled
inputs, and the toolset provides the user-centric capabilities (such
as page interaction) that the deputy (the agent) can invoke. Based on this framing, we characterized the attack surface of an
agentic browser through two dimensions: browser properties and
attacker properties, each of which is further subdivided into two
sub-dimensions each. This includes (1) Browser Capabilities,
defined as the set of all actions available to the model, A,
and (2) Input Data, comprising the rendered page’s HTML
content and visual state, ℎ𝑡
,𝑖𝑡
, which together define the
context available for the model’s reasoning. • Attacker properties.Where the paper says it
Where the paper says it
Where the paper says it
The Taxonomy of Attacks
The paper derives a taxonomy of 20 attacks across both the web and LLM space based on modeling the capabilities of a traditional web attacker and the capabilities provided to the agent. The taxonomy is structured around four dimensions: Browser properties, Attacker properties, Browser Capabilities, Input Data, Attacker Capabilities, and Attacker Target. p. 3 This includes (1) Browser Capabilities,
defined as the set of all actions available to the model, A,
and (2) Input Data, comprising the rendered page’s HTML
content and visual state, ℎ𝑡
,𝑖𝑡
, which together define the
context available for the model’s reasoning. • Attacker properties. By contrast, our taxonomy highlights
the importance of these axes in defining the attack surface of agentic
browsers. It provides a framework for understanding the different
types of attacks that can occur based on the capabilities provided
to the agent and the attacker’s goals and capabilities.Where the paper says it
Where the paper says it
Failure Modes and Generalizability
The authors distill their findings into five broad failure modes based on their threat model: (1) agents bridge cross-site data, (2) agents bridge same-site data, (3) agents hallucinate URLs, (4) websites attack the LLM itself, and (5) agents misuse integrated tools. They show that agentic browsers exhibit these five major failure modes when facing traditional and LLM web threats. p. 0 We further conduct a generalizability
study on 14 of the 20 attacks, showing that our attacks reproduce
across 4 major LLM models spanning multiple vendors. We show
that agentic browsers exhibit five major failure modes when facing
traditional and LLM web threats, demonstrating the need to rearchitect agentic browsers before they are ready for the current
web. We show that 10 web threats can reemerge—often in amplified forms—once an agent can be influenced
by untrusted page content. We further conduct a generalizability
study on 14 of the 20 attacks, showing that our attacks reproduce
across 4 major LLM models spanning multiple vendors.Where the paper says it
Where the paper says it
Implications for Future Defenses
The findings suggest that meaningful protection of confidentiality and integrity will likely require rearchitecting agentic browsers around a security model aligned with their threat model rather than retrofitting safety atop existing designs. Proposed changes include limiting capabilities to the minimum required for the target workflow. p. 5 ACM CCS ’26, June 03–05, 2018, Woodstock, NY Anonymous Author(s)
Table 1: Overview of attacks against LLM browsers. ID Attack name Minimum browser
capability Attacker target Minimum attacker
capability Prompt Web
PoCs
Gen. 2 Extending the See→Act Model
To extend the existing See→Act model, we further break down
𝑎𝑡
into four disjoint operations and introduce the notion of an
origin (𝑜) and a set of elements (E). We note that at every step,
Browser UI
Navigation
Agent
Integration
(Other MCP)
iframe of sensitive
content
read/interact
Privileged
tools
gadget
read/interact
instruct
JavaScript
fingerprint
modify
Page
trigger events
malicious page
navigate
permission pop-up
approve
read/interact
User
Prompt
trigger
DevTools
API calls
trigger
The Web
Figure 3: Agentic browsers in our threat model within the
different capabilities given to the agent.Where the paper says it
Where the paper says it
Conclusion
The paper concludes that agentic browsers require re-architecting before they are ready for the current web because all the 20 attacks studied result in the same five failure modes. The core contribution is establishing a foundation for future work by providing an expert-guided taxonomy of attacks against agentic browsers. p. 1 Finally, while the attack space continues to evolve, this work’s
primary contribution is not an exhaustive enumeration of all possible attacks but rather a unifying structure. By providing the first
expert-guided taxonomy of attacks against agentic browsers, we
establish a foundation for future work to extend, refine, and evaluate the security properties of agentic browsers as the ecosystem
matures.Where the paper says it
References
[1] [n. d.]. Blog | Windsurf. https://windsurf. p. 0 ACM, New York, NY, USA, 17 pages. https://doi.Where the paper says it
[2] Cursor Documentation [n. d.]. Cursor Docs
[3] Dia Browser [n. d.]. Dia Browser | AI Chat With Your Tabs
[4] GitHub [n. d.]. GitHub Copilot · Your AI Pair Programmer
[5] [n. d.]. Introducing Claude Sonnet 4. p. 0 They enable hands-off browsing workflows in which the
user delegates page navigation and interaction to an underlying an
LLM agent. Major technology vendors, including Google [16, 19],
Perplexity [15], Claude [14], OpenAI [18], and Microsoft [12], have
already begun deploying such systems at scale to the masses.Where the paper says it
[6] Microsoft [n. d.]. Microsoft/Playwright-Mcp
[7] [n. d.]. Piloting Claude for Chrome
[8] 2024. Remove Polyfill. p. 9 The
Playwright-MCP harness used OpenAI’s Agent SDK because all
APIs were OpenAI-compatible. 2 Case Studies
In this section, we discuss 6 attacks from our five failure modes:
Same-site action-oriented confusion (SS-4), Universal cross-site
scripting (XS-4), Prompt leakage (LLM-1), Remove-code-execution
(I-5), domain slop squatting (SQ-2), and path slop squatting (SQ1).Where the paper says it
[9] 2025. https://brave. p. 0 ACM, New York, NY, USA, 17 pages. https://doi. ACM, New York, NY, USA, 17 pages. https://doi.Where the paper says it
Where the paper says it
[10] 2025. https://brave.com/blog/unseeable-prompt-injections/
[11] 2025. https://neuraltrust. p. 0 ACM, New York, NY, USA, 17 pages. https://doi.Where the paper says it
[12] Microsoft Copilot 2025. AI Browser: Copilot Mode in Edge
[13] 2025. Browseros-Ai/BrowserOS
[14] 2025. Claude Code | Claude
[15] 2025. Comet Browser: A Personal AI Assistant
[16] 2024. Gemini in Chrome | The next Generation of AI in Chrome | Chrome
[17] 2025. Introducing ChatGPT Agent: Bridging Research and Action
[18] 2024. Introducing ChatGPT Atlas
[19] Google DeepMind 2025. Project Mariner
[20] 2024. Steel-Dev/Awesome-Web-Agents
[21] Devdatta Akhawe, Adam Barth, Peifung E Lam, John Mitchell, and Dawn Song. 2010. Towards a formal foundation of web security
[22] Adam Barth, Collin Jackson, Charles Reis, TGC Team, et al. 2008. The security architecture of the chromium browser
[23] Microsoft Corporate Blogs. [n. d.].
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Enable capability scoping based on workflow requirements to limit an agentic browser's access to unnecessary features, as
Browser-vendors should limit capabilities: Any product using agentic browsers can use our taxonomy to scope agent capabilities to the minimum required for the target workflow.
This reduces the attack surface by preventing agents from accessing features they do not need, such as navigation or general browser UI functionality. -
Implement explicit trust annotations on web content, allowing developers to distinguish between trusted and untrusted regions within a single site. This addresses
the absence of a clear notion of trust within content on the same site,
enabling the agent to make more informed decisions about which content to treat with caution rather than relying solely on brittle model alignment. -
Re-architect enforcement mechanisms based on the agentic browser threat model by introducing static or semi-static rules reflecting common failure modes. This involves
reintroducing enforcement mechanisms that are aware of an agentic security threat model, or by using static or semi-static rules that reflect common failure modes,
to intervene when actions would violate established boundaries. -
Develop context-aware input analysis to distinguish between instructions to the agent and instructions to the user, which is necessary for mitigating
Agents Bridge Same-site Data,
where an attacker embeds malicious signals within otherwise benign content. This requires distinguishingbetween instructions to an agent and instructions to the user.
-
Implement cross-origin boundary enforcement mechanisms that explicitly restrict or monitor data transfers between distinct origins, addressing the failure mode where
agents bridge cross-site data
through actions like acrossorigin read (ar)
and acrossorigin write (aw).
-
Develop predictive path and domain registration systems to counter
Agents Hallucinate URLs,
by anticipating inferred paths or domains that the agent might generate when unable to fulfill a task, thereby preventing attackers from preemptively registering these resources. -
Integrate mechanisms to detect and flag traditional web attack analogs, such as
Cross-site action-oriented confusion (XS-2),
which are more susceptible to models than direct prompt injection attacks. This involves recognizing thatmodels are more susceptible to traditional web-attack analogs than to traditional prompt-injection attacks.
-
Enhance sandboxing and permission models for integrated tools by specifically targeting the manipulation of tool calls, addressing the failure mode where
Agents Misuse Integrated Tools,
which occurs when an attacker forces an agent into executing a tool-call action (axM).
Abstract
Large language models (LLMs) are increasingly being integrated into web browsers to create agentic browsing systems that execute actions on behalf of the user. Prior work considering the security of agentic browsers focuses on indirect prompt-injection attacks. However, by failing to consider traditional web attacks, previous agentic browser threat models have a blind spot to web social engineering attacks originally designed to trick humans. In this paper, we propose the first web-focused threat model for agentic browsers and use it to derive a taxonomy of 20 attacks across both the web and LLM space, and implement 18 of the attacks. Our threat model extends the original See to Act browser agent model to account for all components of a browser, and frames the agent as a confused deputy unable to distinguish task steps from traditional web attacks. We show that 10 web threats can reemerge often in amplified forms once an agent can be influenced by untrusted page content. We further conduct a generalizability study on 14 of the 20 attacks, showing that our attacks reproduce across 4 major LLM models spanning multiple vendors. We show that agentic browsers exhibit five major failure modes when facing traditional and LLM web threats, demonstrating the need to rearchitect agentic browsers before they are ready for the current web.
Sources
- DoomArena: A framework for Testing AI Agents Against Evolving Security Threats
- Why Are Web AI Agents More Vulnerable Than Standalone LLMs? A Security Analysis
- Mind2Web: Towards a Generalist Agent for the Web
- WASP: Benchmarking Web Agent Security Against Prompt Injection Attacks
- EIA: Environmental Injection Attack on Generalist Web Agents for Privacy Leakage
- SOK: On the Analysis of Web Browser Security
- Caution for the Environment: Multimodal LLM Agents are Susceptible to Environmental Distractions
- Breaking ReAct Agents: Foot-in-the-Door Attack Will Get You In
- WIPI: A New Web Threat for LLM-Driven Web Agents
- ReAct: Synergizing Reasoning and Acting in Language Models
- BrowseSafe: Understanding and Preventing Prompt Injection Within AI Browser Agents
- GPT-4V(ision) is a Generalist Web Agent, if Grounded
- WebArena: A Realistic Web Environment for Building Autonomous Agents
Related papers
- From Strategy Search to Policy Learning: MCTS-Guided Adversarial Co-Evolution for LLM Safety Alignment
- Privacy Leakage from Recurrent State in LLM Inference
- Incrementally Verifiable Oracle Aided Computation
- Privilege and confidentiality in generative AI workflows
- BadMoE: Backdooring Mixture-of-Experts LLMs via Routing-Aware Triggers and Task-Underutilized Experts
- CoVault: Secure, Scalable Analytics of Personal Data