Maatrel

Zero trust for AI agents

Runtime assurance for AI agents

Agents now take actions with real authority. The place to decide whether each one should run is inside the agent.

Runtime assurance inside the agentAn agent, drawn as a box, gets its identity from an identity provider and reads documents and tool results. An edited invoice, 1182, makes the agent propose a payment on the route to a SaaS API that no gateway sees; runtime assurance, inside the agent, refuses it. Three allowed actions then pass the same check: one through an AI, API or MCP gateway to MCP servers and APIs, one straight to the SaaS API, one to files and databases. Each decision is recorded on the monitoring line, the refusal as a cross.Runtime assuranceModelAgentmodel, tools, codeIdentity providerwho the agent isWhat it readsdocuments, tool resultsGatewayAI, API or MCPMCP servers and APIsSaaS APIFiles and databasesno gatewayMonitoring and audit recordIDInvoice 1182, editedRefusedRuntime assurance inside the agentAn agent, drawn as a box, gets its identity from an identity provider and reads documents and tool results. An edited invoice, 1182, makes the agent propose a payment on the route to a SaaS API that no gateway sees; runtime assurance, inside the agent, refuses it. Three allowed actions then pass the same check: one through an AI, API or MCP gateway to MCP servers and APIs, one straight to the SaaS API, one to files and databases. Each decision is recorded on the monitoring line, the refusal as a cross.RuntimeassuranceModelAgentmodel, tools, codeWhat it readsdocs, tool resultsIdentity providerwho the agent isGatewayAI, APIor MCPMCP serversand APIsSaaS APIFiles anddatabasesno gatewayMonitoring and audit recordIDInvoice 1182, editedRefused
The edited invoice's payment takes the route no gateway sees. Runtime assurance, inside the agent, is the check it meets.

Agents now act with real authority

AI agents have moved from answering questions to taking actions. They pay invoices, update customer records and call internal systems, often many times a minute, with nobody reviewing each step. A wrong answer can be corrected later; a wrong payment cannot be called back.

Take an accounts payable agent asked to pay invoice 1182. It fetches the invoice through the supplier's MCP server (a standard tool interface for agents), looks up the vendor and pays. The invoice was edited to carry a new bank account, and the agent pays that account. Its identity was valid and the payment tool was the right one; the account number came from a document an attacker could write.

Today's layers each see part of the action

In the past year AWS, Google, Okta and Microsoft all made agent identity generally available, alongside the gateways, guardrails and observability teams already run. Each layer is worth having, and each has its own job. Simplified, here is the question each one usually answers about invoice 1182:

LayerThe question it answersWhat it sees of invoice 1182
IdentityWho is this agent, acting for whom?A valid agent identity
GatewayMay this request go through?A permitted call to the payments API, if the call is routed through it
Model guardrailsDoes this text look harmful?An ordinary invoice
ObservabilityWhat happened?A successful payment, afterwards

Having these layers does not settle whether this payment is justified. That needs one more answer, before the payment runs: does the account number come from a source a payment should trust? None of these layers traces a value back to its source, so none of them can tell the edited invoice's account from the one on file.

Runtime assurance sits inside the agent

Runtime assurance for AI agents makes an agent's actions verifiable and accountable as they happen. Before an action runs, it establishes who asked for it, whether the request and the evidence it relies on are authentic, whether it fits the workflow so far, where its values came from, and whether it is allowed in the current context. It then holds execution to exactly what was checked and records the decision in a tamper-evident history. It is zero trust applied one level deeper: a request is not trusted because of where it comes from, and an action is not trusted because an authorized agent proposed it. It is the layer Maatrel builds.

Inside the agent: the first point where an action can be stopped, and the last point where its full context is in view. For some actions, it is the only one.

  1. IntentThe model proposes an action.
  2. Runtime assuranceThe first point where the action can be stopped.
  3. Leaves the agentFrom here on, only the request travels.
  4. GatewaySees the request, if it is routed there.
  5. ServiceApplies its own checks, then acts.
Full context ends where the action leaves the agent.

Inside the agent, a proposal becomes a concrete action (this tool, these arguments, for this user) that can be refused before anything leaves, while what the user asked, what the agent read and what each tool returned are still in view. Downstream, only the request travels.

For some actions, the only point

Some actions never meet another check that understands agents: the agent's own code, queries sent straight to a database, MCP servers running locally beside the agent, cloud calls made with the agent's own role, and calls that skip the AI gateway (the proxy that routes agent traffic through policy) to reach a SaaS API. The database, the cloud and the service still apply their own controls, but none of them sees why the agent is calling. Keep the agent's keys and permissions usable only through the checked path, and a call that goes around the check has no authority to act. Wrapping the clients alone does not do that if the same keys work elsewhere.

The idea comes from aviation

Aviation trusts software in two ways. Design-time assurance verifies it before it flies. For functions too complex to verify completely, increasingly including machine learning, the industry adds run-time assurance, standardized in ASTM F3269: a simpler monitor that can be verified watches the complex function and keeps it inside a defined envelope. Language models are the new complex function: you do not have to verify the model to bound what it is allowed to do.

Aircraft
  1. Complex functionflight software, machine learning
  2. Simple monitorverified, small
  3. Inside the envelope
AI agent
  1. Language modelproposes actions
  2. Runtime assurancedeterministic, in the agent
  3. Inside the envelope
The same pattern, with a new complex function.

Agents need both. Evaluations and red-teaming are the design-time part: they show how an agent usually behaves, but no test foresees an invoice edited after deployment. Runtime assurance bounds each action as it happens, with a monitor simpler than what it watches: deterministic checks, not another model.

What to ask any runtime assurance product

The largest platforms are moving in this direction. Microsoft has open-sourced its Agent Governance Toolkit, which applies policy inside the agent's process before actions run, and AWS has added session-aware rules to its AgentCore Gateway. Ask any product in this layer, Maatrel included, these questions:

  • Does it decide before the action runs, or report afterwards?
  • Is the decision deterministic, under policies the platform chooses rather than the agent?
  • Does it judge each action on what actually happened in the workflow, such as what the user asked and what tools really returned, or only on what the application passes in?
  • Does it cover the places the agent acts: model calls, tools, MCP servers and outbound APIs?
  • When something cannot be verified, does the action stop?
  • Can you show afterwards what was decided and why, for every decision?

How Maatrel works

Maatrel is runtime assurance for AI agents, built to meet them all. A few lines of code and your policy files wrap the model, tools, MCP servers and outbound API calls an agent already uses, and each request passes seven checks before it runs.

  1. Who asked?Signed request
  2. Under which rules?Policies selected
  3. In its place?Workflow state
  4. With which values?Origin of valuesInvoice 1182 refused here
  5. Knowing what?Rules and context
  6. Doing exactly what?Runs as signed
  7. On what record?Recorded
Seven checks before an action runs. The edited invoice fails the fourth, and the refusal is recorded.

Take invoice 1182 again. The account a payment goes to decides who gets paid, so the policy accepts it only from a source it trusts for that, here the vendor directory. The edited invoice is authentic: it is exactly what the supplier's MCP server returned. Authentic is not authoritative, though. A signature shows where a value came from and that nothing changed it; the policy decides which source counts for which value. The new account number traces only to the invoice, so the payment is refused before the payments API sees it, and the refusal is recorded.

The same checks apply to any agent the wrapped clients serve: payments, customer records, internal systems or SaaS. Conditions use signed tool results, never the model's word, and if something cannot be verified, the action does not run.

Maatrel works with LangChain and LangGraph agents and the OpenAI SDK, their tools and MCP servers, alongside your identity provider and gateway. See each check at work, step by step, on the home page.

Sources

  1. AWS, Amazon Bedrock AgentCore is now generally available (October 2025)
  2. Google Cloud, Agent Identity overview
  3. Okta, Showcase 2026 announcements
  4. Microsoft, What is Microsoft Entra Agent ID?
  5. ASTM F3269-21, Methods to Safely Bound Behavior of Aircraft Systems Containing Complex Functions Using Run-Time Assurance
  6. Microsoft, Agent Governance Toolkit
  7. AWS, Temporal policies in Amazon Bedrock AgentCore (August 2026)

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.