Maatrel

Zero trust for AI agents

Authentic is not authoritative

A signed value can still be the wrong one. Before an agent acts, rules the agent cannot change decide which source counts for which value.

The account number from invoice 1182 passes the first check: it is authentic, exactly what the supplier's server returned. It is stopped at the second: an invoice may not decide who gets paid. The line ends there, refused, and the payment is never sent.
Authentic: signed and unchanged since it arrived. Not authoritative: an invoice may not decide who gets paid.
Bar chart of the attacks that succeeded in AgentDojo's banking suite, without Maatrel and with it.
In AgentDojo's banking suite, 49.7% of attacks succeeded without Maatrel. With it, none of 285 attack runs did.

With Maatrel, the agent still completed 70.6% of the tasks it completed without it (12 of 17). AgentDojo 0.1.35 (suite v1.2), important_instructions attack, gpt-4o-mini-2024-07-18, banking suite, 2 trials each: 143 of 288 attack attempts succeeded without Maatrel, 0 of 285 with; the 3 attempts that errored are left out.

The invoice was authentic

Take an accounts payable agent paying invoice 1182. Someone has edited the invoice to carry a new bank account, and the agent fetches it through the supplier's MCP server. Nothing is forged on the way: the invoice is exactly what the supplier's server returned. Maatrel signs each tool result as it arrives, which proves that the invoice the agent read is the one it received, unchanged.

That proof is real, and it is not enough. A signature shows where a value came from and that nothing has changed it since. It does not show that the source should decide who gets paid. That is the fourth question Maatrel asks before an action runs, with which values, and it is the one that stops this payment.

  1. Who asked?Signed request
  2. Under which rules?Policies selected
  3. In its place?Workflow state
  4. With which values?Origin of valuesThis article
  5. Knowing what?Rules and context
  6. Doing exactly what?Runs as signed
  7. On what record?Recorded
The seven questions Maatrel asks before an action runs.

Two questions for each value

Before the payment runs, the account number has to pass the two tests in the opening figure. Is it authentic: did it come from where it claims, unchanged? And is it authoritative: is that source the one trusted for this kind of value? A signature answers the first. Maatrel also asks the second, and rules the platform team writes answer it, not the agent. Both are asked inside the agent, when the payment is proposed and before the call leaves, while everything the agent read is still in view.

Only some arguments carry authority

Most of what an agent writes needs no special source. A memo line, an email body or a summary can come from anything the agent read. A few arguments are different, because they decide what happens: who gets paid, what command runs, which secret is used. Only those need a trusted source, so the agent stays free to read and write as it normally would.

This is also why a list of allowed tools is not enough. In AgentDojo's banking suite, the benchmark above, the legitimate tasks use the same payment and account tools the attacks use. The user and the attacker call the same tool with the same fields; only where the values came from differs.

How a value is traced

As the agent works, Maatrel keeps what it saw, in order: the user's request and each tool result, each signed when it arrived. When the agent proposes an action, each value in it is traced back to where it appears in that history and takes the trust of that source: a registered system the platform vouches for, the user's own request, or outside content, such as an invoice a supplier's server returned.

What the agent saw: 1, the user asks to pay invoice 1182 from Brightwater; 2, the vendor directory gives Brightwater's account on file, a source that may decide who gets paid; 3, the invoice from the supplier's MCP server, outside content, carries a different account. The agent proposes a payment to the invoice's account. Maatrel looks for that account in what the agent saw and finds it only in the invoice. An invoice may not decide who gets paid, so the payment is refused. The same payment to the account on file is found in the vendor directory, which may decide who gets paid, and it runs.
Each value is traced back to where it was found, and takes the trust of that source.

The tracing holds up against the obvious ways around it:

Values, where each is found, and the trust it earns
The value in the actionWhere it is foundWhat it earns
NL91 ABNA 0417 1643 00The vendor directory, a registered sourceMay decide who gets paid
NL20 INGB 0001 2345 67Only the invoice, outside contentOutside content: not enough
5Almost everywhereNo trust: too common to show where it came from
NL20 INGB 0001 2345 67, with extra spaces or invisible charactersThe invoice, all the sameOutside content: reformatting does not hide a value
“the new account”, in the model's own wordsNo single sourceThe lowest trust
A tool's result worked out from the invoiceThe tool's output, which carries the invoice's originOutside content: a tool cannot pass it off as its own

Trust follows the source: registered platform systems first, then the user's request, then internal tools, then outside content and the model's own words. No model is asked whether anything looks suspicious. The check is deterministic: the same action, with the same history, gets the same answer every time.

Who decides which source counts

The team that runs the agent sets two things, and the agent can change neither. Tools are registered, and the platform's registry decides how far each tool's results are trusted; a tool it cannot vouch for counts as outside content. And the team marks which arguments carry authority, one line each. Nothing is guessed, so the setup can be reviewed like code.

provenance:  tools:    pay_invoice:      roles:        # decides who gets paid        - path: /account          role: target        - path: /amount          role: content    lookup_vendor:      roles:        - path: /name          role: content      field_origins:        # trusted for it        - pattern: /output/*/account          origin_class: registry
Two marked pairs: the account decides who gets paid, and the vendor directory's account field is the source trusted for it.

For invoice 1182, that gives one rule: an account that decides who gets paid must trace to a source above outside content, and the vendor directory is one. The edited invoice's account traces only to the invoice, so the payment is refused before the payments API sees it, and the refusal is recorded.

When the right value arrives in an email

That rule raises an obvious question: what if a new supplier really does send their bank details by email? By the rule, the email cannot decide who gets paid, whatever it says: the account traces only to the email, and the payment is refused. That is also why an instruction hidden in an email, a ticket or a README cannot redirect a payment: stopping it does not depend on recognizing the instruction as an attack.

An email from a new supplier gives a bank account, outside content. The agent proposes a payment to that account, found in the email. An email may not decide who gets paid, so the payment is refused.
The account traces only to the email, so the payment is refused, however genuine the email looks.

Maatrel does not guess whether the email is genuine. Raising a value's trust is an explicit step in the agent's workflow, called declassification: a person, or an automated check the platform authorizes, approves that exact value for a stated use.

The account from the email, GB71 LOYD 3096 1700 7094 43, starts as outside content. Then the step that raises its trust, declassification: a person in accounts payable approves this exact account, for who gets paid, until an hour from now, and the approval is signed by an approver the platform authorized. In the agent's context the account is now approved for who gets paid, and the same payment runs.
One explicit, signed step raises the trust of one exact value, for one use, for a limited time.

The approval covers one exact value, for one use, for a limited time. It is signed by an approver the platform has authorized and verified again at each check. It lifts the value above outside content, which is what the rule asks, but never past the user's own trust. From then on the agent can pay that account, and the record shows which approval allowed it; without an approval, the payment stays refused.

How the benchmark was run

AgentDojo is a public benchmark that hides attacks in the data an agent reads. Its banking suite is the closest to this article's question: eight of its nine attacks try to send money to an attacker's account. The Maatrel configuration allowed every banking tool and named no attack and no attacker account, so every refusal in the chart at the top came from tracing values to their sources. Two further runs in October again let no attack through.

The cost shows in the tasks. Tasks that pay an account found only in a file were refused by design, since the file counted as outside content: that is where a person's approval belongs.

Across all four AgentDojo suites, successful attacks fell from 30.2% to 7.4%, and each attack that still succeeded was of a kind declared out of scope before the run. See the results for each suite and all seven questions at work on the home page.

Sources

  1. Debenedetti et al., AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents (NeurIPS 2024)
  2. Maatrel, Runtime assurance for AI agents

Become a design partner.

We are working with a few teams to secure what their AI agents do. Design partners get the private preview and work with us directly; we ask for honest feedback from running Maatrel on one real agent.

Prefer to talk first? Write to eval@maatrel.ai.

We use your address only to write about Maatrel's release and the preview. Delivered by Formspree and Loops. Privacy notice.