Agent Gateway for GKE Turns Agent Traffic into a Platform Boundary
Agent Gateway for GKE is in Preview, making traffic between agents a governed platform boundary rather than scattered app code.
When one agent calls a database and one internal API, permissions can remain hidden inside application code. With several agents, the edges multiply quickly: a research agent calls a retrieval agent, which calls a data service, while some requests cross project boundaries. A little header handling and an allowlist in every SDK is not a control plane. It is a collection of future debugging sessions.
Google Cloud’s November 12 release notes put Agent Gateway for GKE into Preview. The feature requires GKE version 1.37.2-gke.1042000 or later and is initially supported in europe-west1 and us-central1. Google describes it as a centralized layer for controlling traffic to, from, and between agents on GKE.The release notes
The important question is who may call whom
I would not treat this as another public HTTP entry point. Agent traffic has dynamic tool selection, long responses, and retries. A useful gateway needs context beyond a URL path: caller identity, target agent, policy version, project boundary, and an audit correlation ID.
agent-a -> agent-b -> data-service
identity? policy version? cross-project? retry count?
That is different from a conventional Ingress. Ingress routes an external request to a service. An agent gateway can become a policy hop inside a workflow. It should not replace business authorization, but it can move “may Agent A call Agent B?” out of scattered client configuration and into a platform rule that can be inspected.
Preview means I would keep it off the critical path
The release is Preview, not GA, and its version and regional constraints are explicit. I would start with an isolated cluster or non-critical namespace and two or three agents with no destructive side effects. The tests would cover policy matches, timeouts, streaming responses, error propagation, gateway restarts, unavailable targets, and trace continuity across a multi-agent call.
Google’s notes also describe governance extending to CNCF-conformant Kubernetes clusters outside Google Cloud, including EKS, AKS, OpenShift, and bare metal. That is useful, but “governance support” does not make network trust, identity mapping, certificates, or retry boundaries consistent by itself. Cross-cluster failure behavior is where a diagram usually becomes more honest than a product page.Release notes and cross-project details
I would also pay attention to long-running requests. If Agent A waits for Agent B and the gateway retries after an ambiguous timeout, the operation may happen twice. Idempotency keys and explicit retry budgets belong in the application contract, even if the gateway provides transport policy.
Draw the graph before installing the component
On Kubernetes, it is easy to install a component and design around it afterward. For agents, I would draw every tool call as a directed edge and mark the caller identity, data sensitivity, and side effects. Reading documentation, checking inventory, and deploying code are not equivalent operations and should not inherit one broad “internal” policy.
For example, a research agent might read a cache but not production tables. A deployment agent might create a preview environment but should not receive production secrets. A gateway can help enforce those boundaries only if the service identities are actually separate and the policies are specific.
This is also why I would separate the control plane from the data plane. Traffic should remain reliable while policies are reviewed, versioned, and rolled back. Google’s broader Agent Platform release notes, including Agent Registry skill scanning and governance, point in the same direction: the platform is moving from merely deploying an agent to registering and governing what it can do.Agent Registry release notes
I would not give agents more access because a Gateway exists. I would use it to make the call graph visible and remove edges the workflow does not need. During Preview, the most useful result may not be throughput. It may be a failed request that finally tells me who called whom, which policy allowed it, and which hop deserves the next investigation.
I would also give each edge its own timeout and budget instead of letting the whole workflow share one generous request limit. A research agent may wait for retrieval; a deployment agent waiting for approval should pause rather than retry. At minimum, logs should retain a trace ID, caller service account, target, policy version, response status, and retry count. Those fields connect the gateway view to Kubernetes and database logs, which is where an operator usually needs to continue the investigation.
