Platform & AI Engineering Leaders Intelligence Brief

Executive Summary

Google Cloud Next 2026 marked a decisive inflection point: the era of AI experimentation is formally declared over. Thomas Kurian opened the keynote by reporting that nearly 75% of Google Cloud customers now run AI in production — not pilots, production — and reframed the central engineering challenge accordingly. The question has shifted from "can we build an agent?" to "how do we govern thousands of them?" For platform and AI engineering leaders, this is the defining context for everything that followed.

The headline announcement — the Gemini Enterprise Agent Platform — is best understood as a control plane, not a model capability. Google is not competing on Gemini intelligence alone. It is shipping the Build/Scale/Govern/Optimize operational framework that enterprise platform teams have been improvising themselves, and formalizing it into a unified stack. The four pillars map directly onto the unsolved problems of production agent systems: deterministic workflow construction (Build), persistent state management (Scale), identity and access enforcement (Govern), and end-to-end eval with observability (Optimize). Platform engineering leaders should evaluate this stack not as a vendor offering but as a reference architecture.

Three protocol-level announcements deserve particular attention from anyone building multi-agent systems: A2A (Agent-to-Agent), donated to the Linux Foundation, replaces brittle API contracts between agents with a self-describing agent card model; ATUI (Agent-to-User Interface) allows agents to dynamically generate their own UI components without custom dashboard code; and the Skills standard replaces monolithic system prompts with modular, runtime-selectable capability packages. Together, these protocols represent Google's bid to define the agent interoperability layer — the same way HTTP defined web interoperability. Organizations that adopt them early will have architectural optionality; those that build proprietary alternatives will be refactoring later.

The data points Sundar Pichai shared from Google's own internal deployment are the clearest signal of what is achievable at scale: 75% of new code is now AI-generated and engineer-approved (up from 50% six months prior), a major code migration completed 6x faster via a three-role agent system, security operations now triage tens of thousands of unstructured threat reports monthly with over 90% reduction in threat mitigation time, and marketing teams achieved 70% faster campaign turnaround with 20% higher conversion. These are not aspirational benchmarks — they are the productivity floor that enterprise engineering leaders will be measured against.

Key Findings

Finding 1: The Four-Pillar Framework Is the Platform Architecture

The Gemini Enterprise Agent Platform is organized around four operational pillars that map precisely to the failure modes of production agent systems. Dave Elliott (Director of Product Management) and Addy Osmani articulated this framework in the session "From Prototype to Production: Building with Gemini Enterprise Agent Platform."

Build centers on the Agent Development Kit (ADK), now supporting Python, Go, TypeScript, and Java. ADK 2.0 introduces graph-based workflows that impose deterministic routing on otherwise non-deterministic LLM agents — a critical capability for regulated industries. Shubham Saboo explained in "A Closer Look at Agents CLI" that graph-based routing allows engineers to define precise execution sequences while reserving LLM non-determinism only for the parts that genuinely require it. For financial services or insurance workflows, this distinction is the difference between deployable and not.

Scale addresses persistent state management. Memory Bank is now generally available and self-managing — it makes storage decisions autonomously, removing the expertise barrier from memory architecture. Long-running agents (capable of maintaining state for up to seven days) are treated as a first-class feature. Saboo described pause-and-resume as a single-parameter capability in ADK that saves state, handles interruptions, and picks up exactly where the agent stopped — whether the pause lasts minutes or days.

Govern introduces cryptographically generated agent identities, an agent gateway, an agent registry, and anomaly detection. Elliott and Osmani were unambiguous: shared service accounts are an enterprise anti-pattern. Every agent needs a unique cryptographic identity with auditable authorization policies. The Developer Keynote demonstrated Agent Gateway enforcing IAM policies as a proxy — a read-only finance policy blocking write operations in real time.

Optimize is the newest pillar. Agent Eval addresses the non-deterministic nature of LLMs across the full multi-agent execution flow, providing end-to-end guarantees rather than per-step accuracy. Agent tracing (graph-based visualization of agent actions) and dashboard observability complete the picture. Megan O'Keefe demonstrated in the Developer Keynote how trace views identified a cascading failure caused by exceeding Gemini's 1 million token context limit — and how Cloud Assist then investigated logs, searched GitHub, pinpointed the root cause, and committed a fix autonomously.

Finding 2: Agent Identity and Sandboxing Are No Longer Optional

The Developer Keynote (presented by Ankur Kotwal) was explicit: shared service accounts for agents are the new shared passwords — a security anti-pattern that enterprise teams must retire immediately. Agent identities provide unique, immutable credentials per agent instance. The Agent Gateway enforces egress policies centrally, preventing agents from accessing unauthorized resources even when they are operating autonomously for extended periods.

The integration of Wiz (demonstrated by Yinon Costica) deepened the security picture further. The Wiz security graph maps the full agent architecture and attack surface. A red agent validates whether vulnerabilities are actually exploitable before surfacing them, reducing alert fatigue. A green agent then generates prioritized remediation steps, which a coding agent applies directly in the IDE. The urgency is not theoretical: the Opening Keynote reported that the mean time to exploit a vulnerability is now minus-7 days — exploits arrive before patches exist — and threat actor handoff takes 22 seconds. Machine-speed security responses are not aspirational; they are the minimum viable defense posture.

Agent sandboxes — highlighted by Elliott and Osmani — limit blast radius by scoping tool permissions tightly. An autonomous agent with write or financial access that is not sandboxed is not a prototype risk. It is a production liability.

Finding 3: The Skills Standard Replaces the Monolithic System Prompt

Shubham Saboo's framing in "A Closer Look at Agents CLI" deserves to be treated as architectural guidance: stuffing all agent instructions into a single monolithic system prompt is the engineering equivalent of putting all application logic in a single function. The Skills standard — described as cross-industry, not Google-specific — allows agents to carry modular capability packages that they select and invoke at runtime.

In the Developer Keynote, Mofi Rahman demonstrated Skills as YAML metadata combined with Markdown instruction bodies. Agents load relevant skills only when needed, reducing token consumption and improving accuracy. The Agent CLI is itself built on a Skills library covering platform knowledge, scaffolding, deployment, evaluation, and observability. Saboo noted that installing the Agent CLI globally makes it available to any coding agent — Gemini CLI, Claude Code, Codex — without manual configuration, giving those agents full ADK and platform context automatically.

Tomek Wierzchowski (Staff ML Engineer, Deep Sense AI) confirmed in his session that Skills solve a specific production problem: AI models are not always aware of the latest API updates post-training cutoff. Skills provide a guaranteed link to current documentation, making them essential for rapidly evolving platforms. The Skills and Tools Registry announced in the Opening Keynote extends this further — a centralized registry of reusable modular packages across the enterprise.

Finding 4: Long-Running and Ambient Agents Require Infrastructure Rethinking

The shift from agents that run for minutes to agents that operate for days is not a model capability change — it is an infrastructure change. The seven-day state persistence window for long-running agents, described by both Saboo and Elliott, requires robust persistence layers, event compaction strategies, and context window management that most current platform implementations do not have.

The Developer Keynote demonstrated event compaction as a critical mechanism: periodic summarization of agent workflow history using Gemini, triggered by a configurable token threshold, prevents long-running agents from hitting the 1 million token context limit. Without this, multi-day agents degrade silently — not with an error, but with a context window that slowly fills until the agent cannot reason coherently.

Ambient agents — triggered by external events, incoming messages, or schedules rather than direct user prompts — introduce a different architectural requirement: always-on trigger infrastructure. Saboo described ambient agents as enabling workflows that initiate autonomously based on signals, not requests. For platform engineering leaders, this means the event routing layer becomes as important as the agent runtime layer.

Yasmeen Ahmad (Managing Director, Data Cloud) reinforced the infrastructure implications in "From Systems of Intelligence to Systems of Action": one human click now generates 10 to 20 API calls from agent swarms running multi-step reasoning loops. Organizations that plan infrastructure for human-scale traffic and then deploy agent swarms will face cost and performance surprises. Agent-scale economics require infrastructure planning at a fundamentally different order of magnitude.

Finding 5: A2A and ATUI Are the Interoperability Protocols to Adopt Now

The Agent-to-Agent (A2A) protocol, donated by Google to the Linux Foundation, eliminates the brittle API contracts that currently define most multi-agent architectures. Brad Calder introduced it in the Developer Keynote as a self-describing agent card model: agents advertise their capabilities, and other agents discover and invoke them through the Agent Registry without hard-coded integration points. The Agent Registry functions as DNS for agents — deployed agents are automatically registered and discoverable.

ATUI (Agent-to-User Interface) addresses a different brittle layer: the static dashboard. The current pattern of building custom UI for every agent workflow does not scale to agent fleets. ATUI allows agents to dynamically generate their own UI components using a common design language. Casey West demonstrated this in the Developer Keynote, showing agents producing structured interface elements without custom frontend code.

For platform engineering leaders, the decision is not whether to use A2A and ATUI — it is whether to adopt them now or during a forced refactor later. Every Google Cloud service is now MCP-enabled by default, meaning the integration surface is already standardized on the Google Cloud side. The architectural work falls on the enterprise side: replacing bespoke agent-to-agent contracts with A2A agent cards.

Finding 6: Agent Eval and Observability Are the Confidence Layer

Osmani was direct in the "From Prototype to Production" session: observability is not an afterthought. It is the confidence layer that makes long-running autonomous agents viable in production. Without end-to-end agent tracing and dashboard-level visibility across an agent fleet, operators are flying blind.

The Agent Eval capability in the Optimize pillar addresses the specific challenge of non-deterministic LLM workflows: individual step accuracy is insufficient. End-to-end guarantees across the full multi-agent orchestration flow are what production requires. Simulation capabilities allow engineers to test agent behavior before deploying changes to production agent fleets.

Megan O'Keefe's demonstration in the Developer Keynote was the most concrete illustration: a cascading 400 error caused by context limit overflow was identified via trace view, investigated by Cloud Assist, fixed with a source code change, and deployed via CI/CD — entirely within the observable debugging workflow. Cloud Assist connects to the IDE via MCP, enabling investigations that start in the Google Cloud Console to continue directly in the coding environment. This is the debugging experience that production agent platforms need to make autonomous agents manageable at fleet scale.

Finding 7: Memory Architecture Is a First-Class Platform Concern

Memory Bank going generally available is a signal, not just a product announcement. The fact that Google shipped a self-managing memory system that makes storage decisions autonomously reflects the engineering reality that memory architecture is one of the hardest problems in production agent systems — and the one most commonly underestimated during prototyping.

In the Developer Keynote, Lucia Subatin and Jack Wortherspoon demonstrated fewer than 20 lines of ADK code enabling session management and memory bank integration. AlloyDB's auto-embeddings feature generates vector embeddings automatically based on a specified model, removing manual embedding pipeline construction for RAG. The planner agent in the marathon simulation demo pulled long-term memories from past simulation runs to improve future route planning — demonstrating cross-session learning as a native capability rather than a custom implementation.

Ahmad's observation in "From Systems of Intelligence to Systems of Action" adds the data layer context: clean data with good lineage only gets AI agents to approximately 50% accuracy. The remaining 50% depends on context — business intuition and institutional knowledge historically stored only in expert minds. The Knowledge Catalog uses GenAI to infer schema and semantic relationships across thousands of unstructured documents, making that institutional context agent-navigable without manual annotation.

Strategic Implications

The platform team becomes the agent governance team. As Osmani and Elliott described, the developer role is shifting toward managing fleets of agents rather than writing every line of logic. This is not a reduction in engineering accountability — it is an elevation. Platform engineering leaders will own the infrastructure layer (ADK, Agent Gateway, Agent Registry), the security posture (identity, sandboxing, egress policies), and the observability layer (tracing, eval, dashboards) that make autonomous agents safe to run at scale. Teams that treat this as a tooling question rather than an organizational design question will be caught off guard when their agent fleet reaches the point where manual oversight is no longer feasible.

Multi-agent architecture requires protocol discipline. The temptation to wire agents together with bespoke APIs is the same temptation that produced monolithic codebases. A2A agent cards and the Agent Registry solve the discovery and contract problem. Skills solve the context overload problem. ATUI solves the dashboard proliferation problem. Adopting these protocols now — even before the fleet reaches scale — creates architectural optionality and reduces refactoring debt.

Security posture must match agent autonomy. An agent that can act autonomously for seven days with access to financial systems, code repositories, and communication tools has an attack surface that no human-speed security team can monitor manually. The Wiz integration and Agent Gateway policies represent the minimum viable security architecture for production agent deployments. The mean time to exploit figure (minus-7 days) is not a statistic to note and move on from — it is a design constraint.

Infrastructure planning must account for agent-scale traffic. Ahmad's 10-to-20x API call multiplier per human action is a planning number, not a curiosity. Platform teams that provision infrastructure based on current human-scale usage patterns and then activate agent swarms will hit cost overruns and performance limits within weeks. Capacity planning for agent deployments requires modeling agent-scale API traffic from day one.

The Build/Scale/Govern/Optimize framework is a maturity model. Most enterprise teams are at Build. The teams that will capture disproportionate business value in the next 18 months are those that achieve Scale and Govern simultaneously — persistent agents with identity and sandboxing — before the Optimize layer (eval, observability, simulation) becomes available across all their workflows. The platform investments that feel like overhead today are the ones that enable fleet-scale deployment in 12 months.

Action Items

This Quarter — Evaluate

1. Audit current agent identity practices. Identify every agent or automated system using shared service accounts or fuzzy credentials. Map the blast radius if any one of them were compromised. Prioritize migration to cryptographic agent identities via Agent Gateway before any new agent goes to production.

1. Evaluate ADK 2.0 graph-based workflows against your highest-value regulated workflows. Any process that currently requires humans to enforce execution order (compliance checks, approval chains, sequential validation steps) is a candidate for deterministic graph routing. Run a proof of concept on one workflow this quarter.

1. Assess Skills adoption for your top three agent use cases. Map each agent's system prompt against the Skills standard. Identify which instructions belong in always-loaded context versus runtime-selectable Skills. The goal is not to refactor everything immediately — it is to understand the scope of the architectural work.

1. Run the A2A protocol against your current multi-agent contracts. For every agent-to-agent integration in your current architecture, assess whether it is brittle (hard-coded API contracts) or resilient (self-describing capability advertisement). Prioritize the brittle integrations for A2A migration.

This Quarter — Build

1. Instrument one production agent with the Optimize pillar stack. Deploy agent tracing and observability dashboards on a single production agent before expanding to the fleet. Use the trace data to identify latency hotspots, context window utilization patterns, and failure modes. This is the fastest path to understanding what fleet-scale observability will require.

1. Implement event compaction on any agent that runs longer than 30 minutes. Configure a token threshold that triggers periodic summarization before the context window approaches capacity. Test the compaction behavior under real workload conditions. An agent that degrades silently due to context overflow is more dangerous than one that fails visibly.

1. Pilot one ambient agent use case. Identify a workflow that currently requires a human to initiate — an alert triage, a status check, a data quality scan — and design it as an event-triggered ambient agent. This surfaces the event routing infrastructure requirements early, before ambient agents become a fleet-wide deployment pattern.

This Quarter — Migrate

1. Migrate Memory Bank to GA. If any agent in your stack implements custom session persistence or memory management, evaluate Memory Bank GA as a replacement. The self-managing storage decisions reduce ongoing maintenance overhead and remove a category of operational failure modes.

1. Integrate Agent CLI globally across your development environment. Install the Agent CLI and configure it to be available to all coding agents (including Claude Code and Gemini CLI). The global install gives those agents full ADK and platform context automatically, reducing the time engineers spend on boilerplate scaffolding and configuration.

1. Begin agent security posture review with Wiz integration. Map your current agent architecture against the Wiz security graph model. Identify attack paths that were not visible before agent autonomy introduced new action surfaces. Prioritize authentication bypasses and over-privileged tool access as the highest-risk categories.

Sessions to Watch

| Session | Why It Matters | |---|---| | Google Cloud Next '26 Opening Keynote (Thomas Kurian, Sundar Pichai) | The definitive statement of the Build/Scale/Govern/Optimize framework and the production benchmarks (75% AI code, 90% threat reduction, 6x migration speed) that platform teams will be measured against. | | Google Cloud Next '26 Developer Keynote (Brad Calder, Richard Seroter, Emily Twersky + ensemble) | The most technically dense session: live demos of A2A, ATUI, Agent Gateway, Memory Bank, agent tracing, Cloud Assist debugging, and Wiz red/green security agents in one 67-minute end-to-end build. | | From Prototype to Production: Building with Gemini Enterprise (Dave Elliott, Addy Osmani) | The sharpest articulation of why prototype-to-production is the unsolved problem, with specific guidance on cryptographic identity, sandboxing, Memory Bank GA, and agent eval. Essential framing for platform architecture decisions. | | A Closer Look at Agents CLI (Shubham Saboo) | The technical deep dive on Agent CLI, Skills standard, ADK 2.0 graph-based workflows, long-running agents, ambient agents, pause-and-resume, and Agent Garden templates. The best single session for developers building on ADK. | | From Systems of Intelligence to Systems of Action (Yasmeen Ahmad) | Critical for any team integrating data infrastructure with agent systems: the 50% accuracy gap from missing business context, Knowledge Catalog auto-enrichment, the 10-20x API call multiplier, and BigQuery's 35% speed / 40% cost improvements at agent scale. | | Next '26: The Future of AI Infrastructure (Amin Vahdat) | The hardware co-design story behind TPU 8T and 8I — including the Board Fly topology optimized for agentic low-latency inference — and Vahdat's prediction that the agentic era will drive a CPU resurgence for orchestration and sandboxing workloads. | | Automating Creativity: Building Gen Media Agents with ADK and MCP (Katie Nguyen) | Concrete implementation patterns: MCP server wiring, LLM-as-judge evaluator agents, Skills for specialized capabilities, and self-correcting agentic loops. Useful as a reference architecture for any domain, not just media. |