Generated banner for Agent Platform Architecture
Generated logo for Agent Platform Architecture

Agent Platform Architecture

GoogleOfficialPublished by Google

  • Skill
  • Tool integration
  • Cloud and DevOps
  • Apache-2.0
  • Low risk

From the author

Designs, engineers, and validates enterprise Gemini platform architectures. Use when designing multi-project hierarchies (Host, Central Governance Hub, Runtime Spoke, Tool/MCP Spoke), configuring Agent Gateway, authoring Agent Connectivity Templates (ALL_TRAFFIC vs PRIVATE_RANGES_ONLY), deploying Secure Web Proxy (SWP) with Policy-Based Routing (PBR) or Cross-Cloud mTLS Egress Hubs, configuring Private CA TrustConfig with Internal ALB + Serverless NEG, implementing Unified Access Policies (UAP Policy V2 CEL) and Semantic Governance (SGP), configuring 3P IdP Token Exchange (EntraID/Ping/Okta via ext_proc + STS) or Agent Identity Auth Manager (SPIFFE), enforcing Model Armor Floor Settings and Fail-Closed guardrails, deploying Cross-Project Registry sync, binding ADK agents on Agent Runtime, or executing Day-2 lifecycle operations. Don't use for read-only live log triage or incident diagnosis, or generic Google Cloud Identity and Access Management (IAM) debugging.
— the description by Google

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured framework for architecting and managing enterprise Gemini platform environments. It covers multi-project hierarchies, secure network connectivity via Agent Connectivity Templates (ACT), and advanced governance using Unified Access Policies (UAP) and Model Armor. It is designed for engineers building scalable, zero-trust agent platforms that require specific egress patterns, identity management, and cross-cloud integration.

What it does

  • Designs multi-project hierarchies including Host, Governance Hub, and Runtime Spokes.
  • Configures Agent Connectivity Templates for ALL_TRAFFIC or PRIVATE_RANGES_ONLY egress.
  • Implements security guardrails using Model Armor and Unified Access Policies (UAP V2).
  • Sets up identity and token exchange using SPIFFE and 3P IdP integration.
  • Manages Day-2 lifecycle operations for agent runtimes and connectivity templates.
  • Validates architecture through a structured 3-phase deployment and audit process.

When to use it

  • When designing the network and security topology for a new enterprise Gemini platform.
  • When configuring secure egress and ingress patterns for agent-to-service communication.
  • When implementing cross-project governance and identity boundaries.
  • When troubleshooting connectivity or policy enforcement issues in a Gemini platform stack.

Advantages

  • Provides a standardized, repeatable approach to complex platform architecture.
  • Ensures adherence to zero-trust principles and least-privilege IAM.
  • Reduces configuration drift through clear, domain-specific reference manuals.
  • Supports complex requirements like hybrid mTLS and cross-cloud egress hubs.

Usage examples

“Design a multi-project hierarchy for a Gemini platform with a central governance hub and separate runtime spokes.”
The agent will outline the project structure, VPC layout, and IAM bootstrap requirements for the requested hierarchy.
“How do I configure an Agent Connectivity Template for ALL_TRAFFIC egress?”
The agent will provide the specific YAML manifest and CLI commands to configure the ACT with the required egress mode.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/google/agent-platform-architecture/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip agent-platform-architecture.zip -d .agents/skills

Documentation by Google

Gemini platform Architecture and Engineering Guide

This skill is the reference system for designing, engineering, and validating enterprise-grade Gemini platform architectures across multi-project hierarchies, hybrid/cross-cloud networks, zero-trust identity boundaries, and inline safety/policy enforcement planes.

Usage Attribution

MUST READ: Before executing any gcloud, REST API, or MCP command, you MUST read and follow the instructions in Usage Attribution.

[!IMPORTANT] Architectural Scope and Reference Discipline: Use SKILL.md to select the target topology, egress mode, ingress pattern, and governance plane, then consult the authoritative references/*.md manual for exact CLI commands, REST/YAML schemas, Common Expression Language (CEL) expressions, and Python Agent Development Kit (ADK) runtime code (references/*.md is the single source of truth for all implementation syntax). When remote Model Context Protocol (MCP) tools (such as the Google Developer Knowledge MCP server or Google-managed MCP endpoints) are available, prefer remote MCP tool invocation over raw CLI/REST commands. Do not execute unrequested live mutations against customer projects when asked for architectural designs.

[!CAUTION] Human Approval Gate for Sensitive Operations: Always prompt the user for explicit confirmation before executing commands or applying configurations that grant permissive Identity and Access Management (IAM) bindings (roles/iap.egressor, roles/compute.networkUser, roles/networkservices.admin), modify Organization Policies (constraints/iam.managed.disableAccessPolicyBinding), update Unified Access Policy (UAP) or VPC Service Controls (VPC-SC) policies, or delete resources (REST DELETE ...?force=true or CLI --quiet).


Prerequisites, Authentication, Region, and Billing Setup

  1. Google Cloud SDK, Authentication, and Project Setup:

    • Install the Google Cloud SDK (gcloud) and authenticate CLI and Application Default Credentials (gcloud auth login && gcloud auth application-default login, or set GOOGLE_APPLICATION_CREDENTIALS).

    • Select or create the target project (gcloud projects create {project_id} / gcloud config set project {project_id}), set the default region (gcloud config set compute/region {region}, defaulting to us-central1; see Google Cloud Locations), and enable required APIs:

      gcloud services enable aiplatform.googleapis.com agentregistry.googleapis.com \
        agentidentity.googleapis.com agentidentitycredentials.googleapis.com \
        networkservices.googleapis.com networksecurity.googleapis.com iap.googleapis.com \
        modelarmor.googleapis.com compute.googleapis.com dns.googleapis.com \
        certificatemanager.googleapis.com servicenetworking.googleapis.com
  2. Billing, Least-Privilege IAM, and Product Terminology:

    • Verify an active billing account is attached (gcloud billing projects describe {project_id} --format="value(billingEnabled)") across {host_project_id}, {gov_project_id}, {runtime_project_id}, and {mcp_project_id} (required even when evaluating free-tier allowances; review Google Cloud Pricing).

    • Grant explicit least-privilege IAM roles (roles/aiplatform.user, roles/networkservices.admin, roles/compute.networkAdmin, roles/compute.networkUser, roles/iap.egressor, or a custom role with networkservices.agentGateways.get,networkservices.agentGateways.use,networkservices.operations.get) rather than primitive roles/owner or roles/editor.

    • Use approved product names: Gemini platform, Agent Runtime (reasoningEngines), Agent Gateway (240.0.0.2:443), Agent Connectivity Template (ACT), Agent Registry, and Unified Access Policy (UAP Policy V2) / Semantic Governance Policy (SGP).


3-Phase Architect Workflow and Decision Tree

graph TD
    Start["Enterprise Gemini platform Architecture"] --> Q1{"1. Egress Destinations?"}
    Q1 -->|"RFC 1918 + Google APIs Only"| Priv["ACT: vpcEgress = PRIVATE_RANGES_ONLY<br/>• Direct Private Google Access (PGA)"]
    Q1 -->|"Public Internet, VPC-SC, or Non-RFC 1918 PUPI"| All["ACT: vpcEgress = ALL_TRAFFIC<br/>• 100% Egress via AGW VIP 240.0.0.2:443<br/>• Consolidate Core Google APIs FQDNs"]
    All --> Q2{"2. Layer 7 URL List or Cross-Cloud mTLS?"}
    Q2 -->|"No (Standard NAT)"| Nat["Direct Cloud NAT on PSC-I Subnet<br/>• ENDPOINT_TYPE_VM,ENDPOINT_TYPE_SWG"]
    Q2 -->|"Yes (Next-Hop SWP)"| Swp["Next-Hop SWP (NEXT_HOP_ROUTING_MODE) + PBR<br/>• Internal and Google API DEFAULT_ROUTING bypasses<br/>• Default route via SWP ILB IP<br/>• Exclude PSC-I from manual Cloud NAT"]
  1. Phase 1 — Scope Verification and Architecture Discovery:

    • Scope Boundaries and Single-Region Discovery: Decline generic Google Cloud IAM/Compute/Storage debugging unrelated to the Gemini platform stack or requests to run broad multi-region live project scanning loops, pointing instead to gcloud ai reasoning-engines list --region={region}.

    • Architecture Design and Engineering: Identify the project hierarchy (Host, Governance Hub, Runtime Spoke, Tool/MCP Spoke), egress mode (ALL_TRAFFIC vs PRIVATE_RANGES_ONLY), policy plane (UAP V2, SGP, Model Armor), and target output format (topology specification, gcloud CLI commands, or REST/YAML manifests).

  2. Phase 2 — Draft Architecture Plan and Resource Mapping:

    • Synthesize the topology diagram, project/VPC layout, IAM bootstrap matrix, and security controls using the Domain Router and Symptom Matrix, and map each manual's canonical REST/YAML schema and CLI commands into the target deployment artifacts.

  3. Phase 3 — Post-Deployment and Audit Log Verification:

    • Pair every architecture design with the Post-Deployment and Cloud Audit Log Verification checklist (references/topologies_and_project_layouts.md) and runtime query validation (references/agent_runtime_and_identity.md).


Domain Router and Symptom Matrix

Each reference manual in references/ is the single source of truth for its domain's CLI commands, REST/YAML schemas, quotas, and CEL expressions. Always read the corresponding reference manual before generating configurations or answering domain-specific questions:

Architecture DomainTopics and Architectural Decisions CoveredSymptoms and Failure Modes Routed HereCanonical Reference Manual
1. Project Hierarchy, Shared VPC, VPC-SC, and Custom RoutingMulti-project separation (Host, Governance Hub, Runtime Spoke, Tool/MCP Spoke), PSC-I subnet sizing, cross-project Service Agent IAM bootstrap, VPC-SC perimeters, non-RFC 1918 PUPI/peered custom route exchange, and post-deployment Cloud Audit Log verification.PSC-I IP exhaustion, cross-project attachment or addressGroup permission denials, VPC-SC perimeter blocks, dropped non-RFC 1918 internal routes, or post-deployment verification.references/topologies_and_project_layouts.md
2. Agent Connectivity Template (ACT) and Agent GatewayChoosing ALL_TRAFFIC vs PRIVATE_RANGES_ONLY, ACT and Agent Gateway REST/YAML schemas, control-plane URI formatting, registry attachment limits, and container custom Root CA bundle trust.Control-plane URI validation errors, registry attachment limit errors, or container TLS verification failures ([SSL: UNEXPECTED_EOF_WHILE_READING]).references/agent_gateway_and_act.md
3. Outbound Routing, Next-Hop SWP, PBR, and Hybrid mTLSSource-range Policy-Based Routes (PBR) for PSC-I subnets, Next-Hop Secure Web Proxy (NEXT_HOP_ROUTING_MODE), swg-autogen-nat vs manual Cloud NAT coexistence, gRPC/A2A/WebSocket routing, Spanner SA impersonation, and Cross-Cloud mTLS Egress Hubs (Hybrid NEG).Asymmetric return-routing drops between manual Cloud NAT and swg-autogen-nat, outbound URL filtering on PSC-I interfaces, or cross-cloud mTLS origination over Cloud Interconnect/VPN.references/egress_routing_and_swp.md
4. Ingress ALB, URL Rewrites, Private CA, and 3P IdP STSTwo-Tier and Single-Tier ALB ingress with URL Map hostRewrite/pathPrefixRewrite, Private CA TrustConfig with Regional Internal ALB + Serverless NEG for Cloud Run MCP servers, and 3P IdP (EntraID/Ping/Okta) token exchange via LbTrafficExtension (ext_proc + STS).WebPKI root stripping (NO_ADDITIONAL_ROOTS), empty :authority drops on Serverless NEGs, *.run.app Google-managed certificate mismatches, or OAuth/IAP header collisions.references/ingress_patterns_and_rewrites.md
5. UAP Policy V2, IAP V1, SGP, and Model Armor GovernanceOrganization/Folder/Project UAP Policy V2 and IAP V1 CEL authorization rules, Semantic Governance Policy (SGP CONTENT_AUTHZ), custom AuthzExtension / AuthzPolicy targets, and fail-closed Model Armor Floor Settings, templates, and ADK callbacks.Egress request is not authorized (HTTP 403 / status.code=7) on MCP initialize or tools/list, failed to parse the service URL on AuthzExtension, binary gRPC parser crashes, or fail-open safety bypasses.references/governance_security_policies.md
6. Agent Registry, Consolidated googleapis, and FederationConsolidating core Google APIs FQDNs into a single googleapis service (ALL_TRAFFIC), registering MCP/A2A/REST services, extracting server-generated registryResource UUIDs for roles/iap.egressor, and Event-Driven Spoke-to-Hub Registry Federation.ALL_TRAFFIC agent startup or telemetry blackholing, IAM binding target mismatches on Registry resources, OpenAPI/MCP spec size rejections, or multi-project catalog drift.references/registry_and_federation.md
7. ADK Runtime Packaging, Agent Identity, and Day-2 OperationsPackaging ADK agents with AGENT_IDENTITY (SPIFFE) and Auth Manager, regional residency, BigQuery pre-execution cost guards, in-place ACT updates, reverse-dependency teardown, and external Cloud NAT IP verification.Raw credential exposure, HTTP 409 ABORTED control-plane mutex locks, HTTP 400 FAILED_PRECONDITION (FROM_AGENT_GATEWAY* or contains child resources: sessions), or X-Forwarded-For: 0.0.0.0 when probing *.run.app.references/agent_runtime_and_identity.md

Files

references/agent_gateway_and_act.md

Agent Gateway, Agent Connectivity Template (ACT), and Security Policies

This reference provides technical specifications, YAML templates, REST/CLI commands, resource attribute contracts, and lifecycle management workflows for Agent Gateway, Agent Connectivity Templates (ACT), Authorization Extensions (AuthzExtension), Authorization Policies (AuthzPolicy), and Semantic Governance Policies (SGP).


Table of Contents

  • 1. Architecture: Tenant Bridging and Control Plane Topology: Lines 21-83

  • 2. ACT Egress Modes: ALL_TRAFFIC vs PRIVATE_RANGES_ONLY: Lines 84-108

  • 3. Production Resource Manifests and REST Deployment: Lines 109-203

  • 4. Authorization Extensions and Policies (authzExtensions and authzPolicies): Lines 204-245

  • 5. Operational Gotchas and Container Trust: Lines 246-279


1. Architecture: Tenant Bridging and Control Plane Topology

The Agent Connectivity Template (ACT) defines the foundational networking contract between Google-managed tenant projects (where agent reasoning engines run) and the customer VPC.

graph TD
    subgraph Google Tenant Project
        RE["Agent Runtime (reasoningEngines / ADK Agent)"]
        GW_Proxy["Agent Gateway Envoy Proxy"]
    end

    subgraph Consumer Project
        ACT["Agent Connectivity Template<br/>• vpcEgress: ALL_TRAFFIC<br/>• dnsPeeringConfig: internal.example.com."]
        NA["PSC-I Network Attachment<br/>• ACCEPT_AUTOMATIC<br/>• Subnet >= /26"]
        ConsumerVPC["Consumer VPC Network"]
    end

    RE -->|Local Bonding| GW_Proxy
    GW_Proxy -->|Bound via Template| ACT
    ACT -->|PSC Interface| NA
    NA -->|Enters Network| ConsumerVPC
Control Plane Policy and Extension Hierarchy
+-----------------------------------------------------------------------------------------+
| Agent Connectivity Template (ACT)                                                       |
|   - Template ID: ${TEMPLATE_ID}                                                         |
|   - vpcEgress: ALL_TRAFFIC (or PRIVATE_RANGES_ONLY)                                     |
|   - networkAttachment: projects/${PROJECT_NUMBER}/regions/${REGION}/networkAttachments  |
|   - dnsPeeringConfig: domain: ${PEERING_DOMAIN} -> targetNetwork: ${VPC_NAME}           |
+--------------------------------------------+--------------------------------------------+
                                             |
                                             v (Referenced by Gateway)
+-----------------------------------------------------------------------------------------+
| Agent Gateway (${GATEWAY_ID})                                                           |
|   - Governed Access Path: AGENT_TO_ANYWHERE                                             |
|   - Registries: //agentregistry.googleapis.com/projects/${PROJECT_NUMBER}/locations/... |
|                 (Max 2: 1 global + 1 regional; never register in us/eu multi-regions)   |
+---------------------+---------------------------------------------+---------------------+
                      |                                             |
                      v                                             v
+-------------------------------------------+ +-------------------------------------------+
| IAP Request Authz Extension & Policy      | | Model Armor Content Authz Ext & Policy    |
| • service: iap.googleapis.com             | | • service: modelarmor.REGION.rep:443      |
| • metadata: iapPolicyVersion: "V1" / "V2" | | • metadata: model_armor_settings          |
| • policyProfile: REQUEST_AUTHZ            | | • policyProfile: CONTENT_AUTHZ            |
+-------------------------------------------+ +-------------------------------------------+
                      |                                             |
                      v                                             v
+-------------------------------------------+ +-------------------------------------------+
| Semantic Governance Policies (SGP)        | | Secure Web Proxy (SWP) Egress             |
| • Semantic Governance Policy Engine       | | • Dedicated Proxy-Only Subnet (/26)       |
| • Stripped DNS Trailing Dot Record        | | • Gateway: NEXT_HOP_ROUTING_MODE          |
| • CEL gRPC Exclusion Rule                 | | • Policy-Based Route (PBR) from PSC-I     |
+-------------------------------------------+ +-------------------------------------------+

2. ACT Egress Modes: ALL_TRAFFIC vs PRIVATE_RANGES_ONLY

FeatureALL_TRAFFIC ModePRIVATE_RANGES_ONLY Mode
Outbound DNS ResolutionAll public and private hostnames resolve to synthetic PSC VIP 240.0.0.2:443.Only RFC 1918 / private domains route to VPC; public domains resolve via Google default DNS.
Proxy Interception100% of outbound traffic is intercepted, inspected, and governed by the Agent Gateway Envoy proxy.Only internal private endpoints are intercepted; external SaaS/public API traffic bypasses the gateway entirely.
Internet Egress PathEgresses the consumer VPC through the PSC-I subnet via Next-Hop SWP (swg-autogen-nat on proxy-only subnet, with any custom Cloud NAT using LIST_OF_SUBNETWORKS excluding the PSC-I subnet) or explicit Cloud NAT (--nat-custom-subnet-ip-ranges="${PSCI_SUBNET_NAME}"—or --nat-all-subnet-ip-ranges in dedicated single-subnet VPCs—with ENDPOINT_TYPE_VM,ENDPOINT_TYPE_SWG, which the Agent Gateway control plane validates even when SWP is not deployed).Direct internet egress from Google tenant infrastructure; no static customer egress IP.
Enterprise Use CaseHighly regulated production environments, zero-trust data exfiltration prevention, strict egress auditing.Dev/test sandboxes, internal-only tools where external web scraping is ungoverned.

[!NOTE] Consumer VPC, addressGroup IAM and Registry Prerequisites for ALL_TRAFFIC: 1. Provision a /26 or larger PRIVATE PSC-I subnet (avoiding reserved 10.0.0.0/24 through 10.0.2.0/24 ranges, with Private Google Access enabled; see references/topologies_and_project_layouts.md Section 2.2) and register the consolidated googleapis service with the core Google APIs FQDNs in Agent Registry (see references/registry_and_federation.md Section 4). 2. Creating an ACT auto-provisions Network Security addressGroup act-${TEMPLATE_ID}; grant roles/compute.networkUser (networksecurity.addressGroups.use, networksecurity.addressGroups.get) on act-${TEMPLATE_ID} to the Agent Runtime service agent service-${PROJECT_NUMBER}@gcp-sa-aiplatform-re.iam.gserviceaccount.com (see references/topologies_and_project_layouts.md Section 3.1).


3. Production Resource Manifests and REST Deployment

3.1 Agent Connectivity Template (ALL_TRAFFIC)
name: projects/${PROJECT_NUMBER}/locations/${REGION}/agentConnectivityTemplates/${TEMPLATE_ID}
description: "Production ACT with full egress governance and DNS peering"
accessPath: AGENT_TO_ANYWHERE
accessTypes:
  - PRIVATE
agentCompute: GKE
deploymentModel: CENTRALIZED
egressNetworkConfig:
  networkAttachment: "projects/${PROJECT_NUMBER}/regions/${REGION}/networkAttachments/${ATTACHMENT_NAME}"
  vpcEgress: ALL_TRAFFIC
  dnsPeeringConfig:
    domains:
      - "internal.example.com."
    targetNetwork: "projects/${PROJECT_NUMBER}/global/networks/${VPC_NAME}" # Use ${HOST_PROJECT_NUMBER} in Shared VPC topologies
  # Optional when using Private CA TrustConfig:
  # tlsConfig:
  #   trustConfig: "projects/${PROJECT_NUMBER}/locations/${REGION}/trustConfigs/${TRUST_CONFIG_ID}"
  #   additionalRoots: PUBLICLY_TRUSTED_ROOTS
3.2 Agent Connectivity Template (PRIVATE_RANGES_ONLY)
name: projects/${PROJECT_NUMBER}/locations/${REGION}/agentConnectivityTemplates/${TEMPLATE_ID}
description: "Private-only ACT for internal RFC 1918 tool routing"
accessPath: AGENT_TO_ANYWHERE
accessTypes:
  - PRIVATE
agentCompute: GKE
deploymentModel: CENTRALIZED
egressNetworkConfig:
  networkAttachment: "projects/${PROJECT_NUMBER}/regions/${REGION}/networkAttachments/${ATTACHMENT_NAME}"
  vpcEgress: PRIVATE_RANGES_ONLY
  dnsPeeringConfig:
    domains:
      - "internal.example.com."
    targetNetwork: "projects/${PROJECT_NUMBER}/global/networks/${VPC_NAME}"
3.3 ACT and Agent Gateway REST Deployment Commands
pip install "pyyaml>=6.0,<7.0"
ACCESS_TOKEN=$(gcloud auth print-access-token)
BASE_URL="https://networkservices.googleapis.com/v1/projects/${PROJECT_NUMBER}/locations/${REGION}"

# 1. Deploy Agent Connectivity Template (using act.yaml from Section 3.1 / 3.2)
curl -s -X POST "${BASE_URL}/agentConnectivityTemplates?agentConnectivityTemplateId=${TEMPLATE_ID}" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" -H "X-Goog-User-Project: ${PROJECT_ID}" \
  -H "Content-Type: application/json" \
  -d "$(envsubst < act.yaml | python3 -c 'import sys, yaml, json; print(json.dumps(yaml.safe_load(sys.stdin)))')"

# 2. Deploy Agent Gateway referencing ACT and dual registries (using agw.yaml from Section 3.4)
curl -s -X POST "${BASE_URL}/agentGateways?agentGatewayId=${GATEWAY_ID}" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" -H "X-Goog-User-Project: ${PROJECT_ID}" \
  -H "Content-Type: application/json" \
  -d "$(envsubst < agw.yaml | python3 -c 'import sys, yaml, json; print(json.dumps(yaml.safe_load(sys.stdin)))')"
3.4 Agent Gateway (Standard and Standalone Registry-Only Modes)
name: projects/${PROJECT_NUMBER}/locations/${REGION}/agentGateways/${GATEWAY_ID}
description: "Production Agent Gateway referencing ACT and Agent Registry"
# Mandatory in VPC-SC / SWP-inspected enterprise environments (mutually exclusive with inline networkConfig):
agentConnectivityTemplate: "projects/${PROJECT_NUMBER}/locations/${REGION}/agentConnectivityTemplates/${TEMPLATE_ID}"
# Note: In stable v1 environments without a standalone ACT, omit agentConnectivityTemplate and specify inline networkConfig:
# networkConfig:
#   egress:
#     networkAttachment: "projects/${PROJECT_NUMBER}/regions/${REGION}/networkAttachments/${ATTACHMENT_NAME}"
#   dnsPeeringConfig:
#     domains: ["internal.example.com."]
#     targetProject: "${HOST_PROJECT_ID}"
#     targetNetwork: "projects/${HOST_PROJECT_ID}/global/networks/${VPC_NAME}"
googleManaged:
  governedAccessPath: AGENT_TO_ANYWHERE
registries:
  - "//agentregistry.googleapis.com/projects/${PROJECT_NUMBER}/locations/global"
  - "//agentregistry.googleapis.com/projects/${PROJECT_NUMBER}/locations/${REGION}"

[!IMPORTANT] The Dual-Registry Invariant: An Agent Gateway supports a maximum of two registries, and each entry must use the numeric PROJECT_NUMBER (uint64). When two registries are configured, exactly ONE must be global and the second must be regional (locations/${REGION}; never register custom services manually in us or eu multi-regions).


4. Authorization Extensions and Policies (authzExtensions and authzPolicies)

  • Collections: Manage authzExtensions under networkservices.googleapis.com/v1 and authzPolicies under networksecurity.googleapis.com/v1 (never legacy authorizationPolicies).

  • Agent Gateway Target Rules: When targeting an AgentGateway, omit loadBalancingScheme on both AuthzExtension and AuthzPolicy.target (whereas SecureWebProxy and ForwardingRule targets use INTERNAL_MANAGED). Attach at most 4 CUSTOM AuthzPolicy resources per gateway and omit iamEnforcementMode for active enforcement (see references/governance_security_policies.md for UAP Policy V2, SGP CONTENT_AUTHZ, and Model Armor manifests).

# iap_request_authz_extension.yaml
name: projects/${PROJECT_NUMBER}/locations/${REGION}/authzExtensions/${IAP_EXT_ID}
authority: iap.googleapis.com
service: iap.googleapis.com
timeout: 1s
failOpen: false
forwardHeaders:
  - Authorization
metadata:
  iapPolicyVersion: "V2" # Use "V2" for Unified Access Policy (or "V1" for IAM condition mode)
# iap_request_authz_policy.yaml
name: projects/${PROJECT_NUMBER}/locations/${REGION}/authzPolicies/${IAP_POLICY_ID}
action: CUSTOM
policyProfile: REQUEST_AUTHZ
target:
  resources:
    - projects/${PROJECT_NUMBER}/locations/${REGION}/agentGateways/${GATEWAY_ID}
customProvider:
  authzExtension:
    resources:
      - projects/${PROJECT_NUMBER}/locations/${REGION}/authzExtensions/${IAP_EXT_ID}

5. Operational Gotchas and Container Trust

  • Day-2 Lifecycle (In-Place ACT PATCH, Control-Plane HTTP 409 ABORTED Mutex, Avoiding FROM_AGENT_GATEWAY* Reference Locks via LRO Polling, and ?force=true Runtime Deletion): See references/agent_runtime_and_identity.md.

  • Misleading agent-gateways import Config Validation Error: If agent-gateways import returns "code": 3, "message": "Config validation failed" citing agentregistry.agents.list, enable the API in the project: gcloud services enable agentregistry.googleapis.com --project=${PROJECT_ID}.

  • Custom Container Root CA Trust Injection: When an agent runs in a custom Docker container bonded to an Egress Agent Gateway, export the gateway's root CA (gcloud network-services agent-gateways describe "${GATEWAY_NAME}" --location="${REGION}" --format="value(agentGatewayCard.rootCertificates)" > agw_root.crt) and inject it into the OS, Python (SSL_CERT_FILE, REQUESTS_CA_BUNDLE), and gRPC (GRPC_DEFAULT_SSL_ROOTS_FILE_PATH) trust stores:

FROM python:3.11-slim

RUN apt-get update && apt-get install -y --no-install-recommends \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*

# Copy exported Egress Agent Gateway Root CA into system trust store
COPY agw_root.crt /usr/local/share/ca-certificates/agw_root.crt
RUN update-ca-certificates

# Point Python SSL, Requests, httpx, and gRPC C-core at the updated bundle
ENV SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
ENV REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
ENV GRPC_DEFAULT_SSL_ROOTS_FILE_PATH=/etc/ssl/certs/ca-certificates.crt

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server, Needs a command-line tool

Security

What our scanner noticed· Low risk

  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Google
Publisher
Google (Official)
Source
google/skills · skills/cloud/agent-platform-architecture · commit 2194d3b
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Google.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download agent-platform-architecture.zip