Nov 28, Paris: AI Health Hack #2 with Alan, Qovery and AWS. Applications close Nov 21

Google's Agent Gateway now reaches EKS, AKS and OpenShift: how to get per-agent identity and policy on your own Kubernetes today

Google put Agent Gateway for cross-cloud into Limited Preview on 11 November 2026. Here is what it enforces, and how to build the same per-agent identity, policy, egress control and audit trail on Kubernetes in your own cloud account with tools that are generally available now.

Guillaume Da Silva
Staff Solutions Architect
NOV 19, 2026 · 17 MIN
Google's Agent Gateway now reaches EKS, AKS and OpenShift: how to get per-agent identity and policy on your own Kubernetes today

Key points:

  • Google's Agent Gateway for cross-cloud is a Limited Preview, announced 11 November 2026. It runs Envoy proxies and an identity sidecar inside your EKS, AKS, OpenShift or bare-metal cluster, gives each agent a SPIFFE-based identity, and enforces IAM access policies and Model Armor filters on LLM, MCP and A2A traffic. Access goes through a request form, and the governance plane stays in Google Cloud.
  • You can build the same four controls today from generally available parts: one workload identity per agent (Kubernetes ServiceAccounts, SPIFFE/SPIRE, or EKS Pod Identity, GKE Workload Identity Federation and AKS Workload Identity), a policy engine (OPA Gatekeeper, Kyverno, ValidatingAdmissionPolicy or Cedar), default-deny egress plus an MCP gateway such as agentgateway, and an audit trail shipped off the cluster.
  • Prompt and response filtering is the one piece without a mature open-source twin. Model Armor scans prompts and tool responses for injection and data leaks. If you need that, plan for a commercial filter or keep tools narrow enough that injection cannot do much.
  • For agents that deploy and operate apps, the shortest path is a brokered API. With Qovery, each agent gets its own API Policy Token with an OPA (Rego) policy, evaluated on every request and failing closed, and every action lands in the audit log as policy:<token-id>:<token-name>, on your own AWS, GCP, Azure or Scaleway account or existing cluster.

Qovery · Infrastructure control plane
Build with Claude Code, Deploy with Qovery
Learn more

Last week a customer forwarded me Google's release note with one line on top: "Do we wait for this?" They run agents on EKS, their security team wants each agent to have its own identity and an allow-list of what it can call, and Google had just announced a product that does exactly that, on clusters outside Google Cloud.

My answer was no, at least not for the controls that matter this quarter. I'm Guillaume, Staff Solutions Architect at Qovery, and I spend a lot of my week helping platform teams put agents on Kubernetes without handing them a cluster-admin kubeconfig. Below is what Google shipped, the four controls it bundles, and how to assemble each one yourself on the cluster you already run.

What exactly did Google announce with Agent Gateway for cross-cloud?

On 11 November 2026, Google Cloud put Agent Gateway for cross-cloud into Limited Preview. Per the release notes, it "extends Agent Platform governance to agents that run on Cloud Native Computing Foundation (CNCF)-conformant Kubernetes clusters outside of Google Cloud", naming Amazon EKS, Azure AKS, Red Hat OpenShift and bare-metal clusters. A GKE flavour followed a day later, in Preview, for clusters on GKE 1.37.2-gke.1042000 or higher.

Google's own summary of the goal is to "give each agent a verifiable identity, register agents and MCP servers in Agent Registry, and route their LLM, MCP, and A2A traffic through local Agent Gateway proxies" (AI Weekly, quoting Google). The cross-cloud overview describes how it works:

  • Data plane in your namespaces. Dedicated Envoy proxies plus an "Agent Identity Runtime (AIR) sidecar that brokers workload identities" run inside your cluster.
  • Three planes. A SaaS management plane, a cross-cloud control plane and a "Satellite data plane". You manage policy centrally in Google Cloud, and enforcement happens locally.
  • Identity. Agent Identity assigns each agent a SPIFFE ID and an X.509 certificate that "is valid for 24 hours", rotated automatically.
  • Policy. The Agent Gateway overview lists IAM Unified Access Policies ("access rules that link an agent's identity to approved tools and endpoints in Agent Registry") and Model Armor, which "scans user prompts and tool responses in real time to block prompt injection attacks, sensitive data leaks, and harmful content".
  • Traffic covered. Ingress to agents, egress from agents to tools, remote MCP servers and SaaS APIs, MCP tool calls in both directions, and A2A delegation between agents.

The preview is under Google's Pre-GA Offerings Terms with limited support, and access is gated by a request form. It needs outbound connectivity from your cluster to Google Cloud APIs. The known issues include fail-open not working when the proxy cannot reach Google Cloud, and a gateway that can take "up to two minutes before it accepts connections". It is free during the preview; the products it plugs into bill at standard rates.

Google is upfront about all of this, as you would expect from a preview, but it means your production agents should not depend on it yet.

Which controls does Agent Gateway bundle, and what replaces each one?

Agent Gateway bundles four controls: a per-agent identity, a policy that says what that identity may call, a choke point for egress and tool traffic, and a log of every call. Each has a generally available equivalent on any conformant Kubernetes cluster, and only the prompt-content filter lacks a mature open-source counterpart.

ControlWhat Google's preview usesWhat you can run todayMaturity of the DIY option
Per-agent identitySPIFFE ID + 24-hour X.509 cert via the AIR sidecarOne Kubernetes ServiceAccount per agent; SPIRE for SPIFFE SVIDs; EKS Pod Identity, GKE Workload Identity Federation, AKS Workload Identity for cloud APIsGA. SPIFFE and SPIRE graduated from the CNCF in 2022
Access policyIAM Unified Access Policies tied to Agent RegistryOPA Gatekeeper, Kyverno or ValidatingAdmissionPolicy for the Kubernetes API; Cedar or OPA inside your gateway or appGA (OPA, Kyverno graduated; VAP GA since 1.30); Cedar is CNCF Sandbox
Egress and tool mediationEnvoy proxies for LLM, MCP and A2A trafficDefault-deny NetworkPolicy, Cilium FQDN rules, Istio egress gateway, agentgateway for MCP and A2AGA for network controls; MCP gateways are young but shipping
Content safetyModel Armor on prompts and tool responsesNo equivalent open-source standard; commercial filters or narrow tool scopesGap
RegistryAgent Registry of agents, tools and MCP serversA labelled namespace convention, a service catalog, or your gateway's configWhatever you build
AuditAgent Observability access logs and tracesKubernetes audit policy, gateway access logs, platform audit log, shipped to a SIEMGA

The OWASP Top 10 for Agentic Applications 2026 lists "Identity and Privilege Abuse" (ASI03) among its top risks, which is the problem the first two rows solve. Start there.

How do I give every AI agent its own identity on Kubernetes today?

Give each agent its own Kubernetes ServiceAccount, issue it short-lived tokens through the TokenRequest API, and map that ServiceAccount to its own cloud IAM role. If agents span several clusters or clouds, add SPIRE so each agent gets a SPIFFE ID, which is the same identity format Google's Agent Identity uses.

Layer 1: Kubernetes identity. One ServiceAccount per agent, named so a human can read the audit log, for example agent-triage-bot or agent-claude-code-alice. Bound tokens from the TokenRequest API are audience-bound and expire (one hour by default for Pod-mounted tokens). Never share one bot account across agents. Morgan covered the audit side of this in detail in Kubernetes can't tell which AI agent took action, so I won't repeat the audit policy here.

Layer 2: cloud identity per agent. An agent that reads S3, Cloud Storage or Key Vault should assume its own role, never a node role shared by every pod.

That way the cloud provider's own audit log (CloudTrail, Cloud Audit Logs, Azure Activity Log) names the agent's role, so a bad S3 delete traces back to one agent.

Layer 3: portable identity with SPIFFE/SPIRE. If agents call each other across clusters, or you want mTLS between an agent and its MCP server, ServiceAccount tokens stop being enough. SPIRE attests workloads and issues short-lived SVIDs (X.509 or JWT) carrying a SPIFFE ID such as spiffe://prod.example.com/ns/agents/sa/agent-triage-bot. SPIFFE and SPIRE graduated from the CNCF in August 2022. Because Google's Agent Identity is also SPIFFE-based, an identity scheme built on SPIRE today keeps your options open if you adopt Google's gateway later.

I tell teams that Layers 1 and 2 take an afternoon. Layer 3 is a project, so only start it when you have a cross-cluster or mTLS requirement you can name.

Which policy engine should decide what each agent is allowed to do?

Use an admission policy engine (OPA Gatekeeper, Kyverno or the built-in ValidatingAdmissionPolicy) for what agents may change through the Kubernetes API, and an authorization engine (OPA or Cedar) at the gateway or API layer for which tools and endpoints each agent may call. Agent Gateway's IAM policies cover the second job; admission control covers the first, and you need both.

The two jobs differ in where the decision happens:

  • Admission policy sees every create, update and delete against the API server, with the caller's identity in request.userInfo. It can reject a Deployment patch from agent-triage-bot that touches the payments namespace, or require a task-id annotation on every agent mutation. It never sees an MCP call or an HTTP request to Stripe.
  • Call authorization happens in the proxy or the API the agent calls. It answers "may agent X call tool Y with these arguments?", which is exactly what Google's IAM Unified Access Policies do against Agent Registry.
EnginePolicy languageBest atStatusWatch out for
OPA GatekeeperRegoAdmission control with reusable constraint templates; same Rego can run in gateways and APIsOPA graduated from the CNCF in 2021Rego has a learning curve; userInfo is only available at admission, not in audit mode
KyvernoYAML, CELAdmission rules written as Kubernetes resources; mutation and generationGraduated from the CNCF in March 2026Kubernetes-only; you still need something else for tool calls
ValidatingAdmissionPolicyCELSimple, in-process rules with no extra controllerGA in Kubernetes 1.30Validation only, limited expressiveness
CedarCedarFine-grained, analysable authorization for apps and gateways; RBAC, ABAC and ReBACCNCF Sandbox since October 2025; cedar-access-control-for-k8s for cluster authzKubernetes integration is still experimental

If you already write Rego, OPA is the efficient choice because one language covers admission, gateway and platform API policy. That is also why we picked OPA for Qovery's agent tokens. Kyverno is the friendlier option for a team that thinks in YAML and only needs to govern the cluster API. Cedar's selling point is that policies can be formally analysed, which appeals to security teams who want to prove that no agent can ever reach production secrets, and its joining the CNCF makes it a safer long-term bet than it was a year ago.

A minimal Kyverno rule that keeps every agent out of one namespace looks like this:

YAML
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: agents-stay-out-of-payments
spec:
  validationFailureAction: Enforce
  rules:
  - name: block-agent-writes-in-payments
    match:
      any:
      - resources:
          namespaces: ["payments"]
        subjects:
        - kind: Group
          name: system:serviceaccounts:agents
    validate:
      message: "Agents cannot modify the payments namespace."
      deny: {}

It works only because each agent lives in the agents namespace with its own ServiceAccount, which is why identity comes before policy.

Give every agent its own scoped, audited key.
Qovery API Policy Tokens put an OPA policy on each agent's access to your AWS, GCP, Azure or Scaleway account, or your existing Kubernetes cluster, and record every action under the agent's name.

How do I control egress and MCP tool calls per agent?

Start with a default-deny NetworkPolicy for every agent namespace, allow only named destinations with FQDN-aware rules, and route MCP and A2A traffic through a gateway that authenticates the agent and authorizes each tool call. That combination reproduces the Envoy-proxy half of Agent Gateway.

Network layer. A plain Kubernetes NetworkPolicy can default-deny egress for the agents namespace, but it only understands IPs and ports. LLM APIs and SaaS tools sit behind CDNs with changing IPs, so you want DNS-aware rules. Cilium's toFQDNs policies let you write "agent-triage-bot may reach api.anthropic.com and api.github.com, nothing else". With Istio, an egress gateway forces all outbound traffic through one auditable exit.

Protocol layer. Network rules see a TLS connection to an MCP server. They cannot see that the agent called delete_repository instead of list_issues. For that you need an MCP-aware gateway:

  • agentgateway, originally from Solo.io and now a Linux Foundation project, is a Rust proxy that handles MCP, A2A, LLM and plain HTTP traffic, with authentication and per-tool authorization. It is the closest open-source match to the proxy part of Google's product.
  • The MCP authorization spec builds on OAuth 2.1, so a gateway or MCP server can require a token per client and scope it, instead of trusting whoever connects.

Content layer. DIY gets thin here. Model Armor scans prompts and tool responses for injection and data leakage. I don't know of an open-source project with comparable coverage that I would put in front of production today. My advice is to reduce what an injected instruction can achieve: narrow tool lists per agent, read-only by default, and no credentials the agent can exfiltrate. Then add a commercial filter if your threat model needs one.

Where should the audit trail for agent actions live?

The audit trail should combine three sources, each keyed on the agent's identity: the Kubernetes audit log for cluster API calls, the gateway's access log for tool and LLM calls, and the platform or cloud audit log for everything an agent does through an API. Ship all three off the cluster with fixed retention.

Agent Gateway sends access logs and traces to Google's Agent Observability. On your own stack, the pieces are:

  • Kubernetes API. An audit policy at RequestResponse level for writes from the agents group, Metadata for reads and Secrets. The attribution article has a ready-to-paste policy.
  • Tool and model calls. Your gateway's access log, with the agent identity, tool name and decision on every line.
  • Cloud APIs. CloudTrail, Cloud Audit Logs or Azure Activity Log, which name the per-agent role from the identity section.
  • Platform actions. If agents deploy through a platform API, that platform's audit log names the agent and the change.

Join them on agent identity and timestamp in your SIEM. If the identities differ between layers (a ServiceAccount here, a gateway client ID there, a token name somewhere else), keep one naming convention, agent-<purpose>-<owner>, so a human can follow one agent across all three.

Should you wait for Google's preview or build the controls now?

Build identity, policy and egress control now, because they are generally available and cheap to add; evaluate Google's preview in parallel if you already use Gemini Enterprise Agent Platform and accept a governance plane in Google Cloud. Nothing you build with SPIFFE, OPA and NetworkPolicy blocks you from adopting Agent Gateway later.

Waiting has a cost. Gartner predicts that over 40% of agentic AI projects will be cancelled by the end of 2027, citing "escalating costs, unclear business value or inadequate risk controls". In the projects I see, the risk-control part is the one that stalls approval, and per-agent identity is usually the first thing a security review asks for.

CriterionGoogle Agent Gateway for cross-cloudDIY stack (SPIRE, OPA or Kyverno, Cilium, agentgateway)Brokered platform API (e.g. Qovery)
AvailabilityLimited Preview, request form, Pre-GA termsGA components todayGA platform; API Policy Tokens in Preview
Where policy is managedGoogle CloudYour cluster and GitQovery control plane
Where it is enforcedProxies in your clusterYour clusterQovery API, before any change reaches your cloud account
Covers LLM, MCP and A2A trafficYesYes, with an MCP gatewayNo, covers deploy and operate actions
Prompt and response filteringModel ArmorNot without a commercial add-onNo
Per-agent identitySPIFFE ID, 24-hour certsServiceAccount, SPIFFE ID, cloud IAM roleOne API Policy Token per agent
Outbound dependencyCluster must reach Google Cloud APIsNoneCluster runs the Qovery agent; workloads stay in your account
Operating effortLow once GAMedium to high, owned by your platform teamLow
Best forTeams already standardised on Google's agent platformTeams with a platform team and strict sovereignty rulesTeams whose agents deploy, scale and debug apps

My read is that Google's product is the most complete single package on paper, and Model Armor is a real differentiator. If your agents talk to dozens of MCP servers and your security team wants one console, keep an eye on it. If your agents mostly ship and operate software in your own cloud account, a gateway in front of LLM traffic does little for the riskiest thing they do, which is change production.

Where does Qovery fit, and where doesn't it?

Qovery governs what agents do to your infrastructure. An agent calls the Qovery API, CLI or MCP Server instead of holding a kubeconfig or cloud keys, and Qovery applies the change to Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster. Qovery is not an LLM proxy and does not filter prompts.

The piece I set up most often is the API Policy Token, currently in Preview. In the docs' own words, it is "a second kind of organization token, intended for autonomous agents and narrowly scoped automation" that "carries no role". Instead it carries an OPA policy written in Rego:

  • Evaluated on every request. "The policy is evaluated at authentication time, before the request reaches the endpoint it targets."
  • Fails closed. "Anything other than an explicit true denies the request."
  • Immediate revocation. "The token is looked up on every request, with no caching."
  • Attributed. "Actions are attributed in the audit log as policy:<token-id>:<token-name>, so an agent's activity is distinguishable from a regular API token's."
  • Context-aware. Policies can read the HTTP method, path and body plus resolved organization_id, project_id, environment_id, service_id and cluster_id.

So "agent-triage-bot can read logs and restart services in staging, nothing in production" is a short Rego policy, and the token is the agent's identity. Only organization Owners and Admins can create one, and policies are immutable: to change one, you delete the token and create a new one. I like that constraint, since a policy that cannot be edited quietly is a policy you can audit.

Humans and their agents sit under RBAC with custom roles scoped to projects and clusters. When a developer connects Claude Code over OAuth, the MCP Server acts with that developer's permissions and is read-only unless they opt in to write access. Every call, from the Console, Terraform, the CLI or an agent, lands in the Qovery audit log with the user or token, the tool, the target and the change.

What Qovery does not cover, so you can plan around it:

The combination I recommend most is a sandbox for the agent process, a default-deny egress policy, and Qovery as the only path to production. Agents get a scoped token, and nobody gets a cluster-admin kubeconfig.

How do I set this up with Qovery from Claude Code or Cursor?

Install the Qovery Agent Skills, connect the MCP Server read-only, then ask your agent to create a scoped policy token for any agent that has to run unattended. Four commands, each one approved by you.

BASH|1. Agent Skills for every compatible agent (Claude Code, Cursor, Codex, OpenCode, Gemini CLI)
curl -fsSL https://skill.qovery.com/install.sh | bash

# 2. Or scoped to the current project only
curl -fsSL https://skill.qovery.com/install.sh | bash -s -- --project

# 3. MCP Server for Claude Code over OAuth, read-only by default
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242

# 4. Write access, only when you explicitly want it (also needs write access enabled in the Qovery Console)
claude mcp add --transport http qovery "https://mcp.qovery.com/mcp?read_write=true" --callback-port 4242

Your agent asks you to approve the install script, and the MCP Server opens an OAuth login in your browser. From then on, ask in plain language: "deploy this app to my AWS account with Qovery", or "create a policy token for a triage agent that can read logs and restart services in staging only". The skills deploy and configure; the MCP Server operates what already exists. Start with the AI agent quickstart or the Claude Code integration.

Frequently asked questions
What is Google Agent Gateway for cross-cloud?

Agent Gateway for cross-cloud is a Google Cloud product, in Limited Preview since 11 November 2026, that governs AI agents running on CNCF-conformant Kubernetes clusters outside Google Cloud, including EKS, AKS, OpenShift and bare metal. It deploys Envoy proxies and an identity sidecar into your cluster, gives each agent a SPIFFE-based identity, and enforces IAM access policies and Model Armor filters on LLM, MCP and A2A traffic, with policies managed in Google Cloud.

How do I get per-agent identity and policy enforcement on Kubernetes without waiting for Google's preview?

Give each agent its own ServiceAccount with short-lived tokens and its own cloud IAM role (EKS Pod Identity, GKE Workload Identity Federation or AKS Workload Identity), and add SPIRE if you need SPIFFE identities across clusters. Enforce cluster changes with OPA Gatekeeper, Kyverno or ValidatingAdmissionPolicy, and tool calls with an MCP gateway such as agentgateway. Default-deny egress and an off-cluster audit log complete the setup.

Is SPIFFE/SPIRE required for AI agent identity on Kubernetes?

No. A dedicated ServiceAccount per agent plus a per-agent cloud IAM role covers most single-cluster setups. SPIFFE/SPIRE becomes worth it when agents talk across clusters or clouds, or when you need mTLS between agents and MCP servers. Google's Agent Identity uses SPIFFE IDs too, so SPIRE keeps your identity scheme compatible.

What is the difference between Kyverno, OPA Gatekeeper and Cedar for AI agents?

Kyverno and OPA Gatekeeper are admission controllers: they decide what an agent may create or change through the Kubernetes API. OPA's Rego can also run inside gateways and APIs, so one language covers several layers. Cedar is an authorization language built for analysable, fine-grained access decisions, a CNCF Sandbox project with an experimental Kubernetes integration.

Does Qovery replace Google Agent Gateway?

Qovery covers a different layer. Agent Gateway sits in the traffic path between agents, models and tools. Qovery governs what agents do to your infrastructure: each agent gets an API Policy Token with an OPA policy, actions are attributed in the audit log as policy:<token-id>:<token-name>, and changes are applied to Kubernetes in your own cloud account. Many teams pair Qovery with an MCP gateway and an egress policy.

Can I use Google Agent Gateway and my own controls together?

Yes. Agent Gateway runs as proxies inside your namespaces, so it can sit alongside NetworkPolicies, admission controllers and a platform API like Qovery. If you build identities on SPIFFE now, they align with the format Agent Identity uses, which makes a later move to Google's product, or away from it, less disruptive.

Guillaume Da Silva
About the author
Guillaume Da Silva

Guillaume is a Staff Solutions Architect at Qovery. He helps customers troubleshoot production infrastructure and writes about Kubernetes operations, AI agents, and reliable cloud platforms.

Next step

Give every agent its own scoped, audited key.

Qovery API Policy Tokens put an OPA policy on each agent's access to your AWS, GCP, Azure or Scaleway account, or your existing Kubernetes cluster, and record every action under the agent's name.