Zero Trust for AI Agents: Authorize the Human, Not the Agent

Zero Trust for AI Agents: Authorize the Human, Not the Agent

Table of Contents

A question I keep coming back to when I look at agentic platforms is this: “When an AI agent merges a pull request, who actually approved it?”

The answer most teams give is “the agent did”. The honest answer is that nobody really knows.

That should worry every security leader who is putting agents into production. So in this article I want to walk through the zero trust architecture I’ve put together for an agentic platform to fix exactly that problem. There’s no vendor pitch here and no silver bullet, just a practical design built on open standards that any platform team can adopt in stages.

The AI agent security problem in plain English

Modern agentic platforms don’t run one agent. They run graphs of them.

An orchestrator kicks off a workflow. It hands a task to Agent A. Agent A calls Agent B, and B calls an internal tool server, which calls GitHub, Slack, Jira or an LLM gateway. Somewhere along the way a human might step in to approve something. The work is asynchronous, it hops across services, and it often sits in a message queue before anyone picks it up.

Now ask yourself two questions about the last step in that chain:

  1. Can it prove the message really came from where it claims to? In most platforms today, internal hops are trusted because of where they sit on the network, plus a shared token. Once a message lands in a queue, nobody re-checks it.
  2. Whose permissions is it using? When Agent B acts because Agent A asked it to, B checks its own permissions, not the permissions of the person who started the workflow.

That second one has a name. It’s called the confused deputy problem, and agents are about the most effective confused deputies we have ever built.

Let me paint a picture

Imagine a note lands on the desk of someone in your finance team. It says: “The CEO needs this supplier paid today. Urgent.”

The finance clerk has the authority to make payments. The note came through the internal mail, from a colleague’s desk. So they pay it.

Nobody checked whether the CEO actually wrote the note. Nobody checked whether the CEO is even allowed to approve that payment. The clerk used their own authority to act on a request they couldn’t verify.

Sound familiar? It’s exactly how CEO fraud works. It’s also exactly how most agent-to-agent calls work today.

Swap the clerk for an agent with a GitHub service account. Swap the note for a message from an upstream agent that has just read a malicious web page. The agent has the power to merge code, so it merges the code.

Now what?

Why “just secure the network” isn’t enough

The instinctive fix is mutual TLS or a service mesh. They’re good controls and I want them in place, but they don’t solve this problem, for two reasons.

Agent messages rest in queues. Transport security protects a message while it’s moving. Agent platforms are store-and-forward, so a message can sit in a stream before it’s consumed. The consumer needs to verify the message, not just the pipe it came through.

A mesh still authorizes the caller. mTLS tells Agent B that it’s talking to Agent A. It doesn’t tell B who started the workflow or whether that person was allowed to ask for this action. The deputy is still confused. It just has a better ID badge.

Zero trust principles for agentic workflows

Before getting into components, here are the rules the whole architecture follows. If you only take one section of this article back to your team, take this one.

  1. Never trust, always verify, at every hop. No node is trusted because of where it sits on the network.
  2. Secure the message, not just the transport. The security envelope travels with the message, so whoever finally consumes it can verify it.
  3. Authorize the initiator, not the deputy. Every decision is made against the person or system that started the workflow, never the calling agent’s own permissions.
  4. Make provenance tamper-evident. Every hop and every human approval is a signed link in a chain. If anything is inserted, removed or reordered, verification fails.
  5. Keep policy local and flexible. Each node decides what it’s willing to do. The platform provides the mechanism, and the teams that own each node own its controls.
  6. Fail closed. A missing signature, an unverifiable certificate or an unavailable policy engine all mean the answer is no.
  7. Build on what you already have. Reuse your existing identity provider, group-based access and token tooling rather than inventing new ones.
  8. Keep authority short-lived. Credentials expire in minutes, and the system re-checks them rather than letting anything hold authority indefinitely.

A zero trust architecture for AI agents: three planes

The design adds two new planes alongside the execution plane that already exists.

flowchart TB
    subgraph EP["Execution plane (exists today)"]
        direction LR
        ORCH["Orchestrator"]
        Q["Message queue"]
        A1["Agent A"]
        A2["Agent B"]
        MCP["Internal tool server"]
        INT["Integrations: GitHub, Slack, Jira, LLM gateway"]
    end

    subgraph IDP["Identity plane (new)"]
        direction LR
        CA["Workload certificate authority"]
        TB["Trust bundle"]
    end

    subgraph PP["Policy plane (new)"]
        direction LR
        BUNDLE["Policy bundles, managed in git"]
        DLOG["Decision logs"]
    end

    ORCH ==>|signed| Q ==> A1
    A1 ==>|signed| A2
    A1 ==>|signed| MCP
    A2 ==>|signed| INT

    CA -. "workload identity" .-> A1
    CA -. "workload identity" .-> A2
    CA -. "workload identity" .-> MCP
    TB -. "verify" .-> INT
    BUNDLE -. "policy" .-> A1
    BUNDLE -. "policy" .-> A2
    BUNDLE -. "policy" .-> MCP
    A2 -. "every decision" .-> DLOG

1. The identity plane: every agent gets a verifiable identity

Every agent runtime and internal tool server is issued its own short-lived certificate, known as a workload identity. I recommend SPIFFE/SPIRE for this. It checks that a workload is what it claims to be before issuing the certificate, keeps the private key off disk, and rotates certificates automatically, typically every hour.

If you already run cert-manager, you can use it as a stepping stone. It’s simpler to adopt, but it doesn’t verify the workload before issuing, so treat it as phase one rather than the destination.

The result: every agent can sign what it sends, and every other node can verify that signature offline, without a network call.

2. The message plane: a signed chain of custody

This is the heart of the design. Every message passed between nodes carries a provenance envelope with three parts:

  • The initiation attestation. When a workflow starts, the orchestrator authenticates the caller and issues a short-lived signed statement: this person (or system), with these groups, started this run. That’s the unforgeable root of the chain.
  • The hop chain. Each agent that handles the message adds its own signed entry: who I am, what action I’m requesting, and a fingerprint of the message. Each entry also includes a fingerprint of the entry before it, so the chain works like a tamper-evident ledger.
  • Gate attestations. When a human approves a step, the orchestrator issues a signed record of that approval, which any downstream node can check for itself.
flowchart LR
    I["Initiation
who started this run"] --> H0["Hop 0
Orchestrator"] H0 --> H1["Hop 1
Agent A"] H1 --> H2["Hop 2
Agent B"] G["Gate approval
signed human sign-off"] -.-> H2

Two details matter more than they look:

  • The message body is never modified. The envelope signs a fingerprint of the body, so changing a single character breaks verification, and signing costs the same however large the payload is.
  • Every hop is bound to its run. A validly signed hop from one workflow can’t be cut and pasted into another. Without this check, an attacker could replay a legitimate step in a place it was never meant to be.

The envelope is built on standard signed tokens (JWS), so it fits the token tooling most platforms already have.

3. The policy plane: every node makes its own decision

Before any node does anything, it asks a local policy engine. I use Open Policy Agent (OPA), running alongside each agent or embedded in the service.

The node gives the policy engine everything it needs to decide:

  • Who started this? The verified initiator and their groups.
  • How did the request get here? Every agent that handled it and what each one asked for.
  • Who approved what? Any verified human sign-offs.
  • What is being asked? For example, merge pull request #42 in this repository.

The action happens only if the signatures are valid and the policy says yes.

Policies are written as code, reviewed in git and shipped to each node as signed bundles. Because they run locally, there’s no central authorization service in the hot path to become a bottleneck or a single point of failure. And every decision is logged, which gives you a complete, searchable audit trail of who authorized what, and why.

How this fixes the confused deputy

Let’s go back to the finance clerk.

In this design, the clerk never asks “am I allowed to make this payment?” The question becomes “is the person who started this allowed to make this payment, through this route, with these approvals?”

flowchart TB
    U["Initiator"] -->|"signed: this person started the run"| A["Agent A"]
    A -->|"passes the signed chain on"| B["Agent B
(the deputy)"] B --> Q{"May the INITIATOR do this?
Not: may Agent B do this?"} Q -->|"yes, and the required approvals are present"| DO["Perform the action"] Q -->|"no"| STOP["Refuse and log the decision"]

In practice, that gives you four things:

  1. The initiator’s identity is carried, not guessed. It’s signed at the front door and verified at every step.
  2. Every node authorizes the initiator. Agent B’s broad service account is never the basis for the decision.
  3. Intermediaries are visible. You can write rules like “only merge if the request came through the code-review agent and a human approved it.” Routing a request through a more privileged agent to launder it no longer works.
  4. Prompt injection is contained. If Agent A is tricked into asking for something malicious, Agent B still checks the initiator’s permissions and the required approvals. The injection can change what is being asked for. It can’t change who the request is authorized against.

That last point is the one I’d highlight to any board. We can’t yet guarantee that a model will never be manipulated. We can guarantee that a manipulated model can’t exceed the authority of the human it’s working for.

Human approvals become evidence, not a status flag

Most platforms treat a human approval as a status flag inside the orchestrator’s database. A downstream system just has to trust that it happened.

In this design, when someone approves a step, the orchestrator:

  1. Authenticates the approver and checks they’re allowed to approve in that domain.
  2. Issues a signed approval record that travels with every message from then on.
  3. Re-checks the original initiator’s current permissions before resuming the workflow.

That third step matters. A workflow might wait days for approval. If the person who started it has left the company in the meantime, the workflow should stop, not quietly carry on with authority that no longer exists. Because nothing holds a long-lived token across the pause, it does stop.

The result is that “a human signed off” becomes proof that any system can verify independently.

What this doesn’t do

I want to be upfront about the limits, because overselling security architecture is how trust gets lost.

  • It doesn’t detect prompt injection. That’s a separate, complementary control at the model layer. This design limits the blast radius when an injection succeeds.
  • It doesn’t make agents correct. It limits their authority, not the quality of their output.
  • It doesn’t replace network controls. Network policies and mTLS stay in place. This is defense in depth.
  • It depends on protecting a small number of keys. The certificate authority and the orchestrator’s signing key are crown jewels. They belong in an HSM or cloud KMS, with rotation and tight access control.

How I’d roll it out

The fastest way to kill a security initiative is a big-bang cutover that takes production down. So this rolls out in stages, moving from observing to enforcing:

  1. Phase 0: Identity. Stand up the workload certificate authority and issue identities to the orchestrator, one pilot agent and one tool server. Nothing is enforced.
  2. Phase 1: Sign and observe. The orchestrator starts signing and agents start verifying, but they only log the results. You learn what breaks before anything is blocked.
  3. Phase 2: Policy in dry-run. Deploy the policy engine. Every decision is logged, but actions are still allowed.
  4. Phase 3: Enforce where it hurts most. Turn on enforcement for high-value actions first: merging code, sending messages to customers, deploying.
  5. Phase 4: Enforce everywhere. Every node verifies and authorizes, and human approvals become signed evidence.
  6. Phase 5: Harden the transport. Add mTLS between workloads as a final layer.

Each phase is small, measurable and reversible. That’s what gets it through a change advisory board, and it’s what keeps the engineering teams on side.

The trade-offs to watch

No architecture comes free. These are the areas I’d ask the team to own explicitly:

  • Latency. Verification happens offline and local policy checks take well under a millisecond. Next to an LLM call it’s negligible, but measure it anyway.
  • Revocation. Short-lived credentials (around five minutes) plus re-checks at key points keep revocation delays small. If you need tighter guarantees, add a broadcast channel for revoked identities.
  • Cross-language consistency. Your message fingerprints must match byte for byte across every language in your stack. Standardize on RFC 8785 JSON canonicalization and make a cross-language test suite a release blocker. This is the one that quietly bites teams.
  • Privacy in logs. Log a pseudonymous user ID, not an email address. Your audit trail shouldn’t become a personal data store.
  • Policy ownership. Decide early who writes and reviews policies (security or service teams) and require code-owner approval on changes.
  • Your existing token rules. If your platform has a rule like “only opaque tokens authorize API access”, the signed provenance tokens need a formal, documented exception. Treat them as evidence for a local decision, never as a credential, and reject them if they ever turn up in an Authorization header.

What to ask your team on Monday

If you’re a CISO or security architect with agents heading into production, here are five questions to take into your next platform review:

  1. When an agent performs a sensitive action, can we prove who started the workflow? Not infer it. Prove it.
  2. Whose permissions does each agent use when it acts on another agent’s request? If the answer is “its own service account”, you have a confused deputy.
  3. Are human approvals verifiable by downstream systems, or just a flag in a database?
  4. If a prompt injection succeeds, what is the maximum damage an agent could do? That’s your real blast radius.
  5. Can we show an auditor, for any action, the full chain of who asked, which agents handled it, and who approved it?

If any of those answers make you uncomfortable, you’re not alone. Most platforms were built for speed first, and that was the right call at the time. But agents are getting more autonomy every quarter, and the gap between what they can do and what we can prove they were allowed to do is getting wider.

Closing that gap doesn’t need a new vendor. It needs a clear principle: authorize the human, not the agent. Then you build every hop around it.

Frequently asked questions

What is the confused deputy problem in AI agents?

A confused deputy is a system that uses its own authority to act on a request it can’t verify. In multi-agent workflows, an agent that trusts another agent’s request and acts with its own broad service account can be tricked into doing things the original user was never allowed to do.

How does zero trust apply to agentic workflows?

Zero trust for agentic workflows means every hop is verified: each agent has its own identity, every message carries signed proof of who started the workflow, and each node authorizes the action against that initiator’s permissions rather than its own.

Does zero trust stop prompt injection?

No. Zero trust doesn’t detect prompt injection, but it limits the damage. Because every action is authorized against the human who started the workflow, a manipulated agent can’t exceed that person’s permissions or skip required approvals.


If you’re designing security for an agentic platform and want to pressure-test your architecture, book a strategy session.

Share :

Related Posts

Welcome to AI Security Architects

Welcome to AI Security Architects

AI systems are moving from experiments to production faster than most security architectures can adapt. Models call tools, agents act with real credentials, and sensitive data flows through retrieval pipelines that did not exist a year ago. AI Security Architects is a place to work through what secure design looks like in that world.

Read More