The Agent That Deleted the Inbox: Why Read and Write Calls Need Different Rules
6 min read Fullmakt Team
- agents-gone-wrong
- governance
- policy
- mcp
- a2a
- traceability
- authentication
An operations team gives an assistant access to the shared mailbox so it can “tidy things up”. The agent reads a few hundred messages, decides a long thread of supplier invoices looks like clutter, and deletes it. Nothing was hacked. The credentials were valid, the agent was authenticated, and every call was permitted. The mistake was that deleting mail and reading mail were the same level of permission.
This is one of the most common ways agentic AI goes wrong, and it is easy to prevent. This post explains why reads and writes need different rules, how to express that for MCP and A2A tool calls, and what evidence you need afterwards.
Authentication answers the wrong question
Login handshakes, OAuth tokens and API keys prove who is calling. They say little about what the call will do. A token scoped to “mailbox access” covers listing, reading, moving and deleting alike. The same is true of most database roles, storage keys and SaaS API tokens issued for convenience.
For a human, that gap is covered by habit and caution. An agent has neither. It acts on a plan it assembled from a prompt, so a vague instruction or an injected instruction in a document can turn into a destructive call at machine speed. Coarse scopes mean the credential does not stop it. See our earlier look at permission creep for how those scopes grow over time.
The asymmetry that matters
Reads and writes fail differently:
| Read | Write, delete, send | |
|---|---|---|
| Worst case | Data exposed or a wasted call | Data lost, money moved, message delivered |
| Reversible | Usually | Often not |
| Safe to retry | Yes | Only if idempotent |
| Needs a human | Rarely | When the effect is hard to undo |
A sent email cannot be unsent. A deleted record may exist in a backup, if someone has tested the restore. A payment to a new payee may be final. These are the calls where a one-second pause costs little and a mistake costs a lot.
Four failure patterns
The helpful cleanup. The agent infers intent from an ambiguous goal and applies a delete or archive across a whole set. It is confident and wrong.
The retry storm. A write times out, the agent retries, and the action happens twice or ten times.
The inherited write. In multi-agent setups, a read-only research agent hands a task to a peer that happens to hold write access. The effective permission is the peer’s, not the requester’s.
The tool that changed. An MCP server adds a write tool or changes a tool’s behavior after approval, a pattern covered in our post on MCP rug pulls.
A practical rule set
- Classify operations, not just endpoints. Treat
GET, listing and searching as reads. TreatPOST,PUT,PATCH,DELETE, send, move, upload and rename as writes. Classify protocol-level operations the same way: an IMAP delete is a write even though the transport looks like a mailbox read. - Default agents to read-only. Grant write access per task or per collection of tools, with an owner and an expiry.
- Hold destructive writes for approval. Not every write. Mail send, delete, bulk change and anything above a money threshold. Keep the rule narrow to avoid approval fatigue.
- Hard-deny what no agent should do. Schema drops, wildcard deletes and unbounded exports belong in a deny list, not an approval queue.
- Rate-limit by behavior. A sudden burst of calls, a first-ever use of a tool, or a spike in errors are signals worth escalating even when each call looks fine alone. See runaway agent spend.
- Test the policy, including the failure mode. A policy that silently stops applying is worse than none. Check what happens when it cannot be parsed or reached, as covered in policy that fails open.
- Log the decision, not just the call. Record who delegated, which rule fired, who approved and what happened, so you can answer “why was this allowed?” later. See agent incident forensics.
What this looks like in Fullmakt
Fullmakt is a broker between your agents and the systems and tools they call. Because every call passes through it, the rules above are enforced in one place and not left to each agent’s prompt.
- Operation-aware policy. Policy rules can match the operation of a call, such as an HTTP method or a mail, file-transfer or delete action, so “writes need approval” and “read-only” are one-line rules rather than custom code per tool.
- Hard deny and approval. Rules can deny a call outright or hold it as a pending approval until a person approves or rejects it. Behavioral limits such as calls per minute or first use of a new tool can escalate as well.
- Credentials by reference. The agent never sees the secret. It is resolved when the call is made, so a confused agent cannot copy or reuse it elsewhere. See host-bound credentials.
- Audit trail. Calls, policy decisions and approvals are recorded so an incident review starts from evidence.
- Same controls across MCP and A2A. Whether the agent uses an MCP tool or delegates to a peer, the call goes through the same policy and logging.
The business effect is a different conversation with security and legal. Instead of “we cannot give the agent mailbox access”, it becomes “the agent can read freely, writes above this threshold need a named approver, and every decision is logged”. That is the version that gets approved. It also fits the evidence expectations in SOC 2 and the EU AI Act and ISO 42001 work many teams are doing now.
FAQ
Why not just give the agent a read-only token?
When the upstream system offers one, do it. Many do not, or a task genuinely needs a few writes. A broker lets you allow those specific writes with approval while the credential stays out of the agent’s hands.
Will requiring approval for writes make agents useless?
Not if the rule is narrow. Reads, drafts and low-risk writes run freely. Only irreversible or high-impact actions wait. Teams typically widen autonomy as they see the audit trail, as described in earning agent autonomy.
How do I stop duplicate writes from retries?
Use idempotency keys where the upstream supports them, and cap retries in the agent. Our post on duplicate agentic actions covers both.
Does this apply to agents calling other agents?
Yes. Apply the same read/write distinction to delegated tasks, and make sure the effective permission is the requester’s, not the most privileged peer’s. See cross-organization A2A handoffs.
Is a prompt instruction like “never delete anything” enough?
No. A prompt is a request the model may not follow, especially under injection. Enforce the rule outside the model, on the call itself.
See how Fullmakt brokers credentials and policy for AI agents or browse the Fullmakt blog.