The lethal trifecta in AI agents: reduce what can leak
Aperisa ยท 7 min read
If your AI agent reads your inbox, anyone with your email address can send it instructions. Simon Willison put it plainly: "an attacker can literally email your LLM and tell it what to do!"
Checked on 2026-11-05.
Willison named this risk the lethal trifecta, in his post The lethal trifecta for AI agents (June 16, 2025). An agent that holds private data, reads untrusted content and can reach the outside world can be tricked into sending your data to an attacker. In most real setups you can't remove the untrusted content or the way out. Our view: shrink the leg you do control, the private data each agent can reach. That reduces what can leak. It does not stop prompt injection, and the section on what this does not fix is as important as the rest.
What is the lethal trifecta for AI agents?
Willison's three legs, in his words:
- "Access to your private data"
- "Exposure to untrusted content"
- "The ability to externally communicate in a way that could be used to steal your data"
And the result: "If your agent combines these three features, an attacker can easily trick it into accessing your private data and sending it to that attacker."
The cause is that models follow instructions they find in content. In Willison's words, "LLMs are unable to reliably distinguish the importance of instructions based on where they came from." A web page, an email or a PDF can carry text that reads like an order, and the model may act on it.
He lists reported cases including Microsoft 365 Copilot, GitHub's official MCP server and GitLab's Duo Chatbot, and notes that vendors fixed almost all of them, usually by closing the exfiltration path. The harder case is yours. Willison says MCP "encourages users to mix and match tools from different sources that can do different things," and once you combine tools yourself, no vendor can close that path for you. That is the normal shape of an MCP setup.
Why can't you just cut the other two legs?
Because they are usually the job.
Untrusted content is what most useful agents read. An agent that triages email reads mail from strangers. A research agent reads web pages. A summarizer reads attachments someone else wrote. Remove the untrusted content and the agent has little left to do.
The outbound leg is harder to see than it looks. Willison points out that any tool that can make an HTTP request can carry data out, and that includes loading an image or handing the user a link to click. Those channels live in your harness: web fetch, a browser tool, a send-email skill, a chat reply, a renderer that loads remote images. A data source can't switch them off for you. You can trim them, and you should, but few working agents end up with none.
How do you shrink the private data leg?
This is the leg you can size. The question moves from "can this agent leak?" to "what could it leak if it did?"
OWASP's 2025 entry on prompt injection (LLM01) gives the general rule: "Restrict the model's access privileges to the minimum necessary for its intended operations." For an agent, that comes down to three cuts:
- By data area. A scheduling agent needs your calendar. It has no reason to see bank transactions or identity documents.
- By work or personal. An agent that handles client email doesn't need your family's messages or your medical bills.
- By detail. Many jobs need a number, not the records behind it. An agent that reports monthly spending can work from totals instead of full records, and totals carry less to steal than every transaction with merchant names attached.
Then give each agent its own key with only that slice, so a tricked agent exposes its slice and not the whole store. Revoke the key when the job changes or the agent goes away.
One pattern removes a leg outright for a given agent. Keep the agent that reads strangers' email on a narrow key, and give broad access only to agents that never read outside content, and remember that stored emails and shared documents count as outside content. The broad agent then has private data and maybe a way out, but no untrusted input. That is two legs, not three.
For the setup side, see control what AI agents can see. For several agents working from one shared record, see a context layer for multi-agent setups. For where the keys themselves sit on disk, see MCP API key config security.
What does limiting data not fix?
Prompt injection still works. A limited agent can still be tricked. It just has less to give away. If your scheduling agent reads a malicious invite and has any way to send data out, your calendar can leave. OWASP says "it is unclear if there are fool-proof methods" against prompt injection, and Willison's advice for people who combine tools themselves is blunt: "The only way to stay safe there is to avoid that lethal trifecta combination entirely."
Your own data can be untrusted content. An email a data tool returns to your agent was written by whoever sent it. Reading your inbox through a read-only tool still puts a stranger's text in front of the model. Shrinking the private data leg does not shrink this one.
The outbound leg is still yours to close. So keep outbound tools tight too:
- Turn off web fetch, browsing and send tools on agents that read private data, unless the job needs them.
- Put a human approval in front of sends and posts. OWASP lists "Require human approval for high-risk actions."
- Watch the quiet channels: remote images and links in the agent's output.
Limiting data is one layer. It works best on an agent that has also lost a leg.
Where does Aperisa fit?
Aperisa is a data source for agents, so it works on the private data leg. Give each agent its own key and set what it can reach: which data areas, work or personal, and how much detail, from full records down to totals only. Aperisa enforces those limits on the server. Revoke an agent key and it stops working within 2 minutes.
Aperisa's MCP tools only read. They search and read your records, and none of them sends email or messages, or changes or deletes your data. Each call is logged (tool, status and duration), and you can see it in My Activity. A search sends its query text to Voyage AI to embed it. None of that removes the outbound leg: your agent's other tools live in your harness, and Aperisa has no say over them. Key limits reduce what can leak through those tools. They don't stop an injected instruction.
Size the leg you control
You can't stop your agents from reading text other people wrote, and most of them need some way to reach the outside. What you can decide is how much each one holds when something goes wrong. Give each agent the smallest slice its job needs, cut a leg outright where you can, and keep outbound tools tight on anything that touches private data.
Aperisa connects as a remote MCP server over Streamable HTTP with a Bearer key, and each key can be limited by data area and level of detail. Try it out.
FAQ
Who named the lethal trifecta? Simon Willison, in his post "The lethal trifecta for AI agents", published June 16, 2025. His three legs are access to your private data, exposure to untrusted content, and the ability to externally communicate in a way that could be used to steal your data.
Does limiting an agent's data access stop prompt injection? No. A limited agent can still be tricked by instructions hidden in an email, page or document. Limiting its data reduces what it can hand over if that happens. You still need to keep its outbound tools tight.
Is an agent safe if its data tools are read-only? Not by itself. Read-only data tools don't send anything, but the agent may have other tools that do, such as web fetch or email. And the content a data tool returns, like an email from a stranger, is untrusted content too.
What is the most reliable way to break the trifecta? Remove one leg for a given agent. Willison's advice is to avoid the combination entirely. In practice that means an agent with private data and no outbound tools, or an agent with broad access that never reads outside content, including emails and documents other people wrote.
Sources
- Simon Willison: The lethal trifecta for AI agents (June 16, 2025)
- OWASP Gen AI Security Project: LLM01:2025 Prompt Injection
Questions
Who named the lethal trifecta?
Simon Willison, in his post 'The lethal trifecta for AI agents', published June 16, 2025. His three legs are access to your private data, exposure to untrusted content, and the ability to externally communicate in a way that could be used to steal your data.
Does limiting an agent's data access stop prompt injection?
No. A limited agent can still be tricked by instructions hidden in an email, page or document. Limiting its data reduces what it can hand over if that happens. You still need to keep its outbound tools tight.
Is an agent safe if its data tools are read-only?
Not by itself. Read-only data tools don't send anything, but the agent may have other tools that do, such as web fetch or email. And the content a data tool returns, like an email from a stranger, is untrusted content too.
What is the most reliable way to break the trifecta?
Remove one leg for a given agent. Willison's advice is to avoid the combination entirely. In practice that means an agent with private data and no outbound tools, or an agent with broad access that never reads outside content, including emails and documents other people wrote.
Published
Keep reading
- Why your AI agent keeps acting on a note that was never true
An agent can act on a memory note that was never true or has gone stale. Why it happens, how to fix stale agent memory, and where Aperisa fits.
- Own your data in the AI era: ownership means little without control
To own your data in the AI era, you need control: one record you decide about, access you grant per agent, and access you can take back when you want.
- How to limit AI agent data access: control what your agents can see
Limit AI agent data access below the OAuth scope: split by data area, work or personal, and level of detail, then give each agent its own key you can revoke.