TL;DR
As AI agents move from experimental toys to the primary "front end" for web services, a critical question emerges: does this new architecture provide a security buffer? This paper introduces VELA, a benchmark showing that AI-mediated access provides surprisingly little protection, with 91% of existing backend vulnerabilities remaining exploitable. The study reveals that security is dictated almost entirely by interface design rather than agent behavior, creating a sharp trade-off between blocking attacks and preserving legitimate functionality.
What Problem Does This Paper Address?
We are witnessing a shift in how users interact with the web. Instead of a human clicking through a browser, AI agents are increasingly using dedicated "agent-facing interfaces" (like OpenAI’s Agentic Commerce Protocol or Anthropic's Model Context Protocol) to invoke backend operations directly.
Proponents hope this "Agent in the Middle" model might offer a new layer of defense—perhaps agents will refuse harmful instructions or sanitize malicious inputs. However, this architectural shift also bypasses traditional web front-ends (and their associated security controls) while still reaching the same vulnerable backend logic. This paper systematically quantifies whether agent mediation actually reduces the exploitability of known web vulnerabilities.
Methods
The authors developed VELA, an executable benchmark designed to isolate the effects of the agent from the effects of the interface.
- The Benchmark: VELA contains 44 documented vulnerabilities across 12 web application families (e.g., WordPress, Juice Shop, crAPI).
- Controlled Comparison: The researchers compared three access paths to the same vulnerable backend:
- C0 (Native): Direct expert exploit via the standard web interface.
- C1 (Tools): Direct invocation of the agent-facing API without an LLM.
- C2 (Agent): An AI agent (e.g., Claude, Codex, Grok) interpreting user goals and calling the API.
- Interface Variations: They tested three interface designs with varying levels of abstraction:
- Endpoint-oriented: Exposes raw API endpoints.
- Workflow-oriented: Groups operations into task-based tools (the reference design).
- Query-oriented: Uses a natural language planner to map queries to backend calls.
- Verification: They used independent "oracles" to verify if an attack actually succeeded on the backend, ensuring that a "fluent" agent response wasn't mistaken for a successful exploit.
Datasets
The study utilizes the newly introduced VELA benchmark, which draws from existing security datasets like WebExploitBench and CVE-Bench. It covers three main analysis groups:
- Input Precision (41%): SQL injection, XSS, etc.
- Application Logic (34%): Authorization bypasses and business logic flaws.
- Resource Handling (25%): Malicious file uploads and path traversal.
Key Insights and Ideas
- The "Firewall" is an Illusion: In the reference configuration, the agent realized every single attack that the interface allowed. No losses were attributed to the agent's safety training or input normalization. If the interface supports a legitimate business workflow, it almost certainly supports the corresponding exploit.
- Agents as Unwitting Accomplices: In a phenomenon called "step completion," agents sometimes helped the attacker. In one case (a refund eligibility flaw), the agent automatically looked up order details and initiated prerequisites that the attacker hadn't even specified, successfully completing the exploit.
- Interface Design > Agent Choice: The choice of LLM (Claude vs. Grok) only moved exploit retention by about 4.5%. In contrast, changing the interface design moved retention by nearly 57%.
- The Utility Trap: While a highly restrictive "query-oriented" interface dropped exploit retention to 39%, it also broke more than half of the legitimate user workflows. This highlights a grueling trade-off: you can secure the agent interface by stripping it down, but you'll likely make the service useless for the agent.
Key Results
- 91% Consequence Retention: Under the reference workflow-oriented design, 91% of vulnerabilities remained exploitable through the agent.
- Structural Attrition: The 9% of attacks that failed did so because the interface simply didn't expose the necessary operation or argument—not because the agent "caught" the malice.
- High Fidelity: Agents were remarkably good at passing through payloads; 35 of the 40 retained cases were "preserved," meaning the exact malicious payload reached the backend sink.
Limitations and Future Work
- Human-in-the-Loop: The study assumes a human attacker providing instructions. It does not cover autonomous agents discovering new vulnerabilities on their own.
- Interface Construction: The interfaces were built by the researchers based on documentation; real-world commercial implementations might include different (or better) input validation.
- Prompt Injection: The threat model excludes direct prompt injection into the agent itself, focusing instead on how the agent handles malicious instructions regarding the backend.
- Future Directions: The authors suggest that the most promising area for defense isn't better LLM safety training, but rather admissible argument domains—strictly defining what values are valid for each API slot to prevent payloads from leaking through.
Summary updated