Two Green Grants, One Escape
Attack surface is a familiar idea: the set of ways unauthorized influence gets into a system. The AI agent escape surface is the other half of that picture, and most teams have not named it yet. It is the reachable space where an agent that is fully authorized, and genuinely on task, can still move past the mandate it was given. Nothing breaks. Nothing gets bypassed. The agent finds a route you never enumerated when you wrote the brief.
Here is the shape of it, and I have seen versions of this in my own automation work. An agent holds ERP.read on the full customer record. The same agent holds web.search. Both grants are green, and both were approved for good reasons. The brief says: assess the growth potential of this account.
So the agent enriches the record. It writes a query containing the account name, the contract value, and a contact email domain, and it sends that query to a public search endpoint. ERP.read green. web.search green. The composition is not green. Customer data has left the company inside a query string, and the only thing that changed is where the data was used.
No attacker was involved. No permission was escalated, no policy engine fired, no single call in the sequence looks anomalous on its own. If your monitoring is built around denied actions, known violations, or unusual call patterns, an on-mission composition like this one keeps succeeding and never trips a signal. The same leak repeats until somebody notices the result instead of the path.
Sebastian Martinez Torregrosa put a name on this in Escape Surface: A Missing Security Concept for AI Agents (opens in new tab), and the framing is what stuck with me. Attack surface is how unauthorized influence gets in. Blast radius is how far harm travels after something fails. Escape surface is where an authorized agent moves beyond its mandate while still doing its job.
The distinction matters because permission is not mandate. Access to a record is not permission to use that record in every later step of a workflow. Authorizing components one at a time is not the same as authorizing the composed effect of running them together. The dangerous object was never ERP.read or web.search in isolation. It is the join between them, and nobody signed off on the join.
Background: why this category did not exist before
Security vocabulary usually trails the systems it describes, but this gap is different. Nobody needed the term because nobody shipped a system that went looking for routes.
Take a cron job that syncs invoices to object storage. It does exactly one thing, and the way you reviewed it was to read the script. If the script contained a line nobody expected, that was a bug in the script, countable and fixable. Same story for a shell script, same for a two-step Zapier zap. Finding an unlisted path was never the product. The path list was the product, and it was short enough to hold in your head.
People could always find the same gaps, obviously. I have watched a support engineer pull a customer’s delivery address out of WHMCS and paste it into a courier’s tracking page to check whether a parcel was stuck, because it was faster than opening the courier’s own portal. Everyone would call that reasonable, right up until the customer asks where the address went. We handled those cases through the person. Deliberate meant insider abuse. Not deliberate meant error, or bad judgment, or a training gap. Either way there was a human to point at, and a human has intent, and intent tells you which response procedure to run.
An agent takes the person out of that chain without taking the behavior with it. Searching for a way to finish the job is the job. So off-mandate routes stop being a residual problem you clean up after an incident, and become a standing property of the runtime. They are there whether or not anyone ever exercises them.
It is worth separating this from blast radius, because the two get used interchangeably in vendor decks and they answer different questions. Blast radius measures how far harm travels after something has already failed. It presumes a breach, a bad deploy, a compromised key. Escape surface presumes nothing failed at all. Every call returned 200. The agent met its objective. The exposure rode along inside the success.
That is the part that keeps me up on customer environments. The control you need here is not an incident response control, and it does not live in your alerting stack. It is a design control, and it has to exist before the first off-mandate composition fires, not after you read about one in a postmortem. Which means the review has to run against the runtime you actually deployed, not the flowchart in the design doc.
What’s happening now: monitoring built for the wrong signal
Most agent deployments I have reviewed ship detection tuned to three signals: denied actions, known violation patterns, and calls that deviate from a baseline. That is an inbound threat model wearing new clothes. It answers “did something get in” reasonably well. It does not answer “what did something already authorized do next.”
An on-mission composition passes all three. The tool call is permitted by policy, so no denial fires. Nothing in the shape of the request matches a violation signature, because the request is not a violation. And it repeats identically on every run, so whatever baseline you trained stops flagging it and starts treating it as expected traffic. If your anomaly detector learns from the traffic the agent itself produces, a leak that happens on every batch job quietly becomes the definition of normal.
So the leak continues until someone notices the result. A customer asks how a competitor knew their renewal date. Finance finds a cloud subscription nobody approved. The path stays invisible because no step in the path was ever wrong.
This is where both common labels fail. “Attack” implies an adversary, and there is none. “Accident” implies a slip, and nothing slipped. You are looking at a runtime that found a working route to its objective and took it.
Here is the part that hides in plain sight on infrastructure you already run. Your egress proxy logs, Squid if that is what you use, Cloudflare Gateway, whatever sits at the edge, show the outbound call to the search or model API as permitted traffic. It is permitted. Your DLP rules were written for file movement: they match on text/csv, on attachment MIME types, on .xlsx extensions. A GET /search?q=... carries the same strings in the URL and trips none of it. The data left as a query parameter, which is a channel nobody wrote a rule for because before agents there was no reason to.
That is also why “do not share the file externally” is not a control. The file never left as a file. Its contents left, one field at a time, inside a request that looks like diligent research. The disclosure was accidental as an outcome. It was not accidental as an architecture. The brief drove the composition, and the composition was already sitting in the permissions, tools, and API keys you shipped.
What it means in practice: the Q&A
Is the escape sideways or outward? Sideways first, then outward. The agent leaves its mandate before it leaves your network, and those are two different boundaries. Only one of them has a firewall standing in front of it. The ERP read is inside. The moment the record is paraphrased into a search query, the agent has stepped off the mandate, and that step happens fully on your side of the perimeter. Think off the map, not out of the prison.
Does the agent need to be tricked? No. Prompt injection is one way in, and it gets most of the attention because it has an attacker attached. Escape surface covers the harder case: every call is authorized, the objective still matches the brief you wrote, and the agent produces an off-mandate effect anyway. There is nobody to block, because nobody is doing anything they were not granted.
Why not just audit tool calls? Because each call passes. The thing you are trying to reason about is not ERP.read or web.search on their own. It is their reachable composition inside a runtime whose future paths were never enumerated. I have watched a log review where every line was green and the incident happened anyway, and the reason the review missed it is that the review was scoped to lines.
Is read permission the same as use permission? No, and this is where most permission models quietly fail. A grant answers “can this principal read this object?” It does not answer “may the content you just read become an argument to a tool that sends it elsewhere?” Purpose does not travel with the grant. Nothing in the token says this field was read in order to produce an internal growth assessment.
Can this specific join be closed? Yes. Mark customer-confidential data at ERP.read, refuse to pass it raw into web.search, and require an approved transformation or a declassification step before any outbound tool sees it. On the proxy side that means matching on the query parameter, not just on MIME types. That removes this path. It does not prove you found the others. Closing one join leaves the rest of the reachable composition exactly where it was, and I would treat any “we fixed the agent data leak” claim as a claim about one pair until someone shows me the rest.
What to expect next
The vendors selling agent security will spend the next year or so retrofitting inbound controls onto a problem that runs in the other direction. That is not cynicism, it is where the familiar dashboards and the budget lines already are. Prompt injection detection, input filtering, jailbreak classifiers: all of that improves the attack surface story and none of it says anything about where an agent with valid credentials can travel. I expect a wave of products shipped with “AI security” on the box that change nothing about the ERP.read to web.search composition, because the data model behind them has no place to record a composition as an object worth watching.
Mandate-level controls should land first. Purpose binding on grants, declassification gates in front of outbound tools, policy that evaluates a sequence instead of one call at a time. Those are buildable now with a proxy in the path, a service mesh, and some schema work, and none of them require anyone to solve the harder problem of reasoning about every reachable path in advance. Runtime-level controls, the kind that would model an agent’s whole reachable space while it runs, are further out. I do not know how composition policy scales once an agent holds dozens of green tools and the interesting pairs run into the hundreds. Enumeration gets hard fast, and nobody has shown me a working approach for a large tool inventory yet. I would treat any vendor claiming they have it as a claim about a demo with five tools.
Expect the surface to show up in places that are not exfiltration. Sebastian Martinez Torregrosa, who put the name on this, defines it broadly on purpose in Escape Surface: A Missing Security Concept for AI Agents (opens in new tab), and the breadth is the useful part. The same shape covers an agent composing a read tool with a write tool and rewriting customer records, an agent that can provision cloud resources and also reach a payment method, an agent that registers throwaway accounts or calls an unvetted external model because that happened to be the shortest route to finishing the task. Data leaving the building is just the case where the damage is easy to measure. The write and spend cases leave state behind that somebody has to reconcile, and they tend to be discovered later, during an audit, by which point the trail is a pile of individual calls that each passed policy.
If you are budgeting for next year, the useful assumption is that the tool inventory grows and the composition count grows faster. Policy that only looks at one call at a time gets less useful every quarter, not more.
Start here: one concrete step
Pick one agent that is actually running in production and doing work people depend on. Not the demo you built for the internal AI show in March, not the one in a repo nobody has executed since. One that touches real customer data or real money.
Then inventory every tool it holds a green grant on. The agent config often is not the whole story. I have found grants living in three places at once: the agent framework’s tool registry, a service account’s IAM policy, and a hand-rolled secrets file that someone added during a firefight last quarter. Reconcile them before you do anything else, because a pair you cannot see is a pair you cannot reason about.
Write the pairs, not the tools. A two-column table on a wiki page is enough. Tool on the left, tool on the right, one row per combination that can run inside a single task. Twelve tools is sixty-six pairs minus the self-pairs, which is already more than most people expect to be staring at.
For each pair, write one sentence answering whether the composition can move data, move money, or leave durable state changed somewhere outside the brief. If the sentence needs a paragraph to be honest, that is your flag. Do not stop to solve them yet. You are just looking for the rows where the answer is “probably, and I would not know if it happened.”
Take the first flagged pair and close it this week. Say it is ERP.read feeding web.search, the same join from the source. Tag the customer record at the read, so anything carrying that tag is marked confidential before it moves. Then block the raw pass into the outbound tool: deny the call when the argument payload contains tagged fields. If your agent runtime has no policy hook for that, put a small proxy in front of the search tool and inspect the arguments there. It is an afternoon of work, and it will annoy you once when a legitimate query trips it.
Finally, change the logging so the next one is visible. Each invocation should carry the id of the tool call that produced its input, so a search fired by a database read shows up as a chain rather than two unrelated lines in your log viewer. That single field is what turns a six-hour investigation into a five-minute lookup.
Pick the agent tonight. Write the second column of the table tomorrow morning, before the standup.