WAAA! Web Adversaries Against Web Agents

arXiv:2605.05509 · cs.CR · Submitted 2026-05-06 · Read on arXiv

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

Where the paper says it

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.

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. p. 0
Where the paper says it

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.

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

Where the paper says it

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.

This 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. p. 0
Where the paper says it

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.

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

Where the paper says it

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]).

This threat model characterizes the attack surface through two dimensions: Browser properties and Attacker properties. p. 3
Where the paper says it

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.

Browser properties include Browser Capabilities and Input Data, while Attacker properties include Attacker Capabilities and Attacker Target. p. 3
Where the paper says it

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.

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

Where the paper says it

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.

This structure highlights how attacks depend on the capabilities provided to the agent and the attacker’s goals and capabilities. p. 5
Where the paper says it

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.

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

Where the paper says it

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.

Furthermore, they conduct a generalizability study on 14 of the 20 attacks, showing that their attacks reproduce across 4 major LLM models spanning multiple vendors. p. 0
Where the paper says it

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.

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

Where the paper says it

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.

Additionally, they suggest enabling developers to annotate web content with trust levels to address the absence of a clear notion of trust within content on the same site. p. 3
Where the paper says it

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.

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

Where the paper says it

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.

References

[1] [n. d.]. Blog | Windsurf. https://windsurf. p. 0

Where the paper says it

ACM, New York, NY, USA, 17 pages. https://doi.

com/blog

[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

Where the paper says it

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.

5

[6] Microsoft [n. d.]. Microsoft/Playwright-Mcp

[7] [n. d.]. Piloting Claude for Chrome

[8] 2024. Remove Polyfill. p. 9

Where the paper says it

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).

Io Code from Your Website Immediately

[9] 2025. https://brave. p. 0

Where the paper says it

ACM, New York, NY, USA, 17 pages. https://doi.

p. 0
Where the paper says it

ACM, New York, NY, USA, 17 pages. https://doi.

com/blog/comet-prompt-injection/

[10] 2025. https://brave.com/blog/unseeable-prompt-injections/

[11] 2025. https://neuraltrust. p. 0

Where the paper says it

ACM, New York, NY, USA, 17 pages. https://doi.

ai/blog/openai-atlas-omnibox-prompt-injection

[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

  1. 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.

  2. 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.

  3. 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.

  4. 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 distinguishing between instructions to an agent and instructions to the user.

  5. 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 a crossorigin read (ar) and a crossorigin write (aw).

  6. 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.

  7. 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 that models are more susceptible to traditional web-attack analogs than to traditional prompt-injection attacks.

  8. 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

Related papers