Google Cloud Tech
Enterprise AI adoption stalls on compliance and fragmentation unless organizations replace in-house infrastructure with integrated governance and runtime stacks that allow decentralized teams to deploy autonomous workflows.
AI-assisted summary of What's new in Google Cloud's agent platform — original source. Check the original for full context.
Source published:
Key ideas
- Google Cloud unified Gemini Enterprise and its agent platform into a single runtime and governance stack, using Gemini Enterprise as the knowledge worker front door and Agent Studio as the developer workbench. (3:51)
- Agent Engine runtimes now support subsecond cold starts, bring-your-own-container environments, and autonomous plan execution for up to seven consecutive days without human intervention. (8:50)
- Enterprise governance tooling reached general availability with Agent Identity for auditable IAM integration, complemented by the Agent Registry, Agent Gateway, and Model Armor for real-time prompt injection defense. (10:39)
- L'Oréal demonstrated enterprise agent adoption at scale, shifting from custom-built infrastructure to Google Cloud's platform to support 41,000 weekly active users and over 30,000 zero-code agents. (24:26)
Detailed notes
## Background Published by Google Cloud Tech on YouTube on June 25, 2026, this Google Cloud Next 2026 breakout session explores the evolution of Google Cloud's enterprise agent platform. According to the description, the presentation details the unified Gemini Enterprise Agent Platform, the Agent Development Kit (ADK), Agent Registry, and enterprise governance, observability, and evaluation suites designed to build, scale, and govern AI agents.
## TL;DR Google Cloud product and developer relations leads Aman Khan and Lavi Nigam unveil major architectural upgrades to their agent ecosystem, framing the evolution of enterprise AI as a shift from basic chatbots to high-performance, autonomous execution engines. The session details enhancements across the Agent Development Kit (ADK), a new Agent CLI, subsecond runtime cold starts, seven-day continuous task execution, persistent Memory Banks, and general availability for Agent Identity and code execution sandboxes. Following a live console walkthrough of Agent Studio and distributed tracing, L'Oréal engineering leaders Thomas Menard and Gauthier Debuiche demonstrate how they scaled their Beauty Tech Platform to 41,000 active users and 30,000 zero-code agents using a centralized control tower gateway and a federated organizational model.
## Atmosphere & style The session has the energetic, authoritative rhythm of a flagship tech conference breakout, balancing keynote-caliber ambition with tactical engineering depth. Aman Khan sets a brisk, grounded tone with vivid analogies about trading reliable sedans for autonomous Formula One cars, which flows seamlessly into Lavi Nigam's granular live console demonstrations and L'Oréal's fast-paced enterprise case study. The dynamic between platform creators and enterprise practitioners creates an inspiring yet pragmatic atmosphere, emphasizing that true agentic scale hinges on unglamorous essentials like security boundaries, auditable governance, and internal enablement.
## Bulletin - [03:51](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=231s) Google Cloud unified Gemini Enterprise and its agent platform into a single runtime and governance stack, using Gemini Enterprise as the knowledge worker front door and Agent Studio as the developer workbench. - [08:50](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=530s) Agent Engine runtimes now support subsecond cold starts, bring-your-own-container environments, and autonomous plan execution for up to seven consecutive days without human intervention. - [10:39](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=639s) Enterprise governance tooling reached general availability with Agent Identity for auditable IAM integration, complemented by the Agent Registry, Agent Gateway, and Model Armor for real-time prompt injection defense. - [24:26](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1466s) L'Oréal demonstrated enterprise agent adoption at scale, shifting from custom-built infrastructure to Google Cloud's platform to support 41,000 weekly active users and over 30,000 zero-code agents.
## Key takeaways - [00:13](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=13s) Enterprise AI is shifting from conversational retrieval-augmented generation (RAG) bots to autonomous execution agents operating with rigorous, Formula One-style guardrails. - [03:51](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=231s) The platform stack is vertically integrated across three layers: user touchpoints in Gemini Enterprise, agent runtime and governance services, and the underlying AI Hypercomputer and Agentic Data Cloud. - [06:34](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=394s) The Agent Development Kit (ADK) introduces graph-based workflow orchestration, agent-to-agent collaboration, event-driven reactive loops, and reusable native skill definitions. - [06:34](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=394s) A new Agent CLI functions bimodally, running standalone terminal commands or feeding architectural skills directly to coding assistants like Gemini Code Assist and Cloud Code. - [08:50](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=530s) Agent Engine supports long-running continuous plans up to 7 days, bidirectional streaming for multimodal voice interactions, and subsecond cold starts with custom container packaging. - [08:50](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=530s) Sessions and Memory Bank address conversational amnesia by maintaining long-term, framework-agnostic state, user preferences, and failure histories across sessions. - [10:39](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=639s) Secure code execution sandboxes and GUI interactions allow agents to execute scripts and manipulate graphical computer desktops safely within isolated environments. - [10:39](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=639s) Agent Identity is generally available, giving agents auditable role-based access controls identical to human users, while Agent Registry catalogs every agent's accessible tools and backend endpoints. - [10:39](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=639s) Model Armor and Agent Gateway provide control plane security by intercepting prompt injections, halting data exfiltration, and regulating external tool routing. - [13:43](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=823s) DeepMind evaluation methodologies and automated 'auto-raters' are embedded directly into the platform for online and offline trajectory evaluations without third-party tools. - [15:12](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=912s) Agent Studio features visual low-code building, access to pre-built agents in Agent Garden, centralized MCP server management, and native RAG Engine grounding. - [18:14](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1094s) End-to-end distributed tracing ties telemetry spans directly to unique ADK session IDs, allowing engineers to isolate tool call failures and inspect step-by-step payloads. - [22:49](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1369s) Gemini Enterprise functions as the universal enterprise conversational interface, where employees invoke governed backend agents using simple '@' mentions in the prompt bar. - [24:26](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1466s) Faced with managing 15 million monthly messages and bespoke scaling bottlenecks, L'Oréal executed a make-to-buy decision to adopt Google Cloud's ADK and Agent Engine. - [27:42](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1662s) L'Oréal implemented an enterprise 'Control Tower' architecture using an API gateway to discover, reuse, and govern agents across internal apps, SaaS systems, and external models like Claude. - [29:25](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1765s) Scaling adoption requires balancing technical toolkits with a 'human stack' comprising a Center of Excellence and an embedded champion relay network dubbed 'The Lineup'. - [32:50](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1970s) Central platform teams achieve sustainable enterprise scale by transitioning from building bespoke services for departments to empowering federated teams to build their own governed products. - [35:20](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=2120s) L'Oréal built a dedicated, agent-powered platform web application that provides self-service onboarding, a shared component catalog, side-by-side model benchmarking, and reusable safety guardrails.
## Detailed walkthrough ### [00:13](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=13s) The Shift from Chatbots to Enterprise "Race Cars"
Aman Khan, Group Product Manager on the agent platform team focusing on agent governance, opens the session by welcoming the packed room and expressing his excitement to dive deeper into what was just announced during the keynote. Joined by Lavi Nigam from the DevRel team—who is slated to run live demos—as well as partner presenters Gauthier Debuiche and Thomas Menard, Khan sets out to show how enterprises are already putting Google Cloud's agent platform into production workflows. Reflecting back exactly one year, Khan recalls when audiences were first introduced to the Agent Development Kit (ADK), Agent Engine, and flashy showcases like the autonomous plant store. By November, baseline governance and deployment features were introduced to help teams bridge prototype to production. Yet today, organizations face a stark reality: while industry and underlying AI technologies are accelerating exponentially, enterprise adoption remains stuck in a flattening logarithmic curve weighed down by compliance hurdles, security approvals, and the friction of organizational alignment.
```mermaid flowchart TD accTitle: End-to-End Enterprise Agent Architecture accDescr: The three-tiered stack connecting consumer and employee touchpoints down to infrastructure.
subgraph ConsumerLayer["Experience Layer"] A["Gemini App Enterprise / Custom Apps & Partner UIs"] end
subgraph PlatformLayer["Gemini Enterprise Agent Platform"] B["Agent Development Kit (ADK) & CLI"] C["Agent Engine Runtime & Sandboxes"] D["Sessions & Memory Bank"] E["Registry, Gateway, Identity, Evals & Observability"] end
subgraph FoundationLayer["Google Cloud AI Foundation"] F["AI Hypercomputer"] G["Agentic Data Cloud"] H["Agent Defense"] end
ConsumerLayer --> PlatformLayer PlatformLayer --> FoundationLayer ```
To break through that flattening adoption curve, companies cannot rely on incremental adjustments; they require fundamental step functions in how they operate. Khan highlights that the era where every AI demo was merely a retrieval-augmented generation (RAG) chatbot is over. Today, agents act as the actual engines of business execution. Illustrating the operational risk of moving beyond simple scripts, Khan shares a vivid automotive analogy:
> “Everyone can get in a Toyota Camry and drive it. It's a reliable car. It's stable, runs well. That's traditional software development. But with agents, we're building race cars. We're building Formula One race cars.”
Driving a Formula One car cannot be done in "YOLO mode," just as one would not put an autonomous vehicle on self-driving mode and simply floor the accelerator. Surveying the room, Khan asks how many attendees have tried or even heard of open-core autonomous frameworks, pointing out that letting unconstrained agent frameworks loose inside an enterprise is a crazy proposition unless hardened guardrails, context, and end-to-end integration are built into the architecture from day one.
---
[03:51](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=231s) Unifying Gemini Enterprise and the Agent Platform Stack
To eliminate the disjointed processes that plague modern enterprise IT, Google Cloud is combining Gemini Enterprise with the agent platform into a single cohesive narrative and runtime environment. In this model, Gemini Enterprise acts as the universal front door for everyday knowledge workers across the company, while the agent platform serves as the central workshop where developers and AI engineers build back-end capabilities. Khan underscores that this architecture removes the traditional "handoff tax" between back-end engineering teams and the customer-facing or internal apps where work actually gets done, allowing both business data and intelligent agents to traverse the enterprise without friction.
Underneath the user interface layer sits the agent platform layer, providing runtimes, component registries, API gateways, enterprise identity, observability, and evaluation suites. All of this rests directly on Google Cloud's core AI infrastructure: the AI Hypercomputer, the Agentic Data Cloud, and Agent Defense security primitives. By supplying a fully vertically integrated stack, Google Cloud relieves developers from having to cobble together four or five disparate vendors just to secure and run a reliable agentic workflow. The agent platform focuses on three strategic pillars: - **Ecosystem and Interoperability:** Broad open-source native tooling support so developers never feel locked into rigid proprietary patterns. - **Ease of Use:** Low-friction onramps that allow cross-functional teams—from AI product managers to software engineers—to build and collaborate in a shared workspace. - **Customizability:** Deep extensibility to ground agents in proprietary organizational data and business policies, recognizing that purely generic out-of-the-box agents cannot solve complex enterprise needs.
---
[06:34](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=394s) Foundation Upgrades: ADK Advancements and the New Agent CLI
Moving into the core developer toolset, Khan details major enhancements to the Agent Development Kit (ADK), Google's foundational open-source agent harness framework. Within Alphabet, ADK is heavily dogfooded, powering projects across experimental internal bets as well as mission-critical consumer products. New capabilities in ADK are designed to handle everything from small utility bots to sprawling multi-agent fleets: - **Graph-Based Orchestration:** Developers can explicitly model intricate business workflows with branching logic, cyclical loops, and conditional checkpoints. - **Agent Collaboration:** Instead of cramming every enterprise responsibility into one fragile monolithic agent, teams can cleanly decompose tasks across specialized agents. - **Batch and Event-Driven Workflows:** Agents can proactively listen and react to real-time asynchronous enterprise events rather than purely sitting idle waiting for a human prompt. - **Native Skill Definitions:** Reusable skills can now be defined once within ADK and distributed across all agents across the enterprise.
To streamline the developer onboarding experience, Khan announces the launch of a new Agent CLI and specialized agent skills for scaffolding, evaluating, and deploying agents. The CLI incorporates deep architectural awareness of both ADK and the Google Cloud agent runtime. It is engineered to operate bimodally: developers can feed the CLI and skills directly into existing coding agents—such as Gemini Code Assist, Cloud Code, or Codex—enabling the AI coding assistant to make sound architectural choices autonomously. Alternatively, engineers can run the CLI commands as standalone terminal workflows to automate environment scaffolding, evaluation sweeps, and Cloud deployment.
---
[08:50](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=530s) Scaled Runtimes, 7-Day Autonomous Execution, and Long-Term Memory
Building an agent is only half the battle; scaling it reliably in a production cloud environment presents an entirely different set of operational challenges. Khan explains that Google Cloud's agent runtime has been re-architected to deliver subsecond cold starts, while introducing bring-your-own-container (BYOC) support so enterprises can package custom dependencies and run on their own terms. Furthermore, addressing the challenge of long-running operations where agents previously stalled out without human nudges, the Agent Engine now supports agents executing a single autonomous plan without human intervention for up to seven continuous days.
The runtime also introduces bidirectional streaming, tailored for ultra-low-latency real-time voice and multimodal interactions similar to the Gemini Flash experiences demonstrated during the keynote. Crucially, Khan tackles the problem of conversational amnesia:
> “Without memory, your agent has no idea what happened yesterday, what the user prefers, what failed last time.”
To turn isolated interactions into compounding enterprise intelligence, Google Cloud is introducing Sessions and Memory Bank. Memory Bank equips agents with persistent, long-term state across sessions, allowing them to recall historical preferences, track past task failures, and learn from user interactions over time. Because the session infrastructure is entirely framework-agnostic, teams can customize schema fields to automatically log specific telemetry, such as real-time user feedback, directly into the agent's long-term memory. Finally, moving from conversation to direct system action, Khan highlights that secure code execution sandboxes are now reaching General Availability (GA), giving agents safe, isolated environments to run code against enterprise workflows.
[10:39](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=639s) Sandboxes, GUI Interaction, and End-to-End Governance
Connecting agents to the physical and digital world requires isolated, flexible runtime environments. With bring-your-own-container support, teams can define custom environments tailored to strict compliance or specialized dependency requirements. Agents can now directly interact with graphical user interfaces (GUIs) to operate computers just like human operators, running safely inside isolated sandboxes. As the speaker explains, context makes agents smarter, while sandboxes make them genuinely useful:
> “Together, you go from a chatbot that answers questions to an autonomous system that remembers what it's supposed to be doing, how to do it and can actually go and execute tasks.”
Turning an autonomous system loose in the enterprise, however, demands a unified governance model rather than an ad-hoc collection of disparate point solutions. Aman Khan stresses that governance cannot simply be a patchwork assembled from legacy systems or external vendors, but must operate continuously across the entire life cycle—from the agent runtime all the way through evaluation and optimization.
To anchor this architecture in organizational trust, Agent Identity is now generally available (GA). With Agent Identity, administrators manage an agent's permissions identically to any human user within the organization, backed by granular, auditable authorization controls for every action. To solve the pervasive question haunting compliance officers, risk officers, and developers—*what agents actually exist across my enterprise?*—the platform introduces the Agent Registry. Agents registered via the runtime or the registry system expose a clear inventory detailing what tools they access and what underlying services they can invoke. Security is further bolstered by Model Armor, which actively intercepts prompt injection attacks and halts data leaks in real time, while integrated proactive threat management monitors agent behaviors. Overseeing all agent traffic is the new Agent Gateway, an extensible control plane allowing organizations to enforce strict policies over tool usage and external communication.
> “We think governance should span from prototype to production, and it includes the perimeters and boundaries to define what your agent can and cannot do in your environment.”
```mermaid flowchart TD accTitle: End-to-End Enterprise Agent Governance Architecture accDescr: Diagram showing how agent traffic flows through Agent Gateway, Model Armor, and Agent Registry down to the Sandbox runtime. subgraph ControlPlane["Control & Inspection Plane"] GW["Agent Gateway\n(Traffic & Tool Control)"] MA["Model Armor\n(Prompt Injection & Leak Defense)"] TM["Proactive Threat Management\n(Live Monitoring)"] end subgraph Governance["Governance & Identity"] ID["Agent Identity (GA)\n(Auditable RBAC / IAM)"] REG["Agent Registry\n(Tool & Service Catalog)"] end subgraph Execution["Execution Sandbox"] SB["Custom Containers & GUI Sandboxes\n(Isolated Execution)"] end
GW --> MA MA --> TM TM --> ID ID --> REG REG --> SB ```
- **Bring-Your-Own-Container**: Allows organizations with strict infrastructure requirements to supply custom execution environments for agent tasks. - **GUI Interaction**: Agents are equipped to interact directly with graphical desktop interfaces to perform end-to-end computer tasks within secure sandboxes. - **Agent Identity (GA)**: Assigns manageable, audit-ready identities to autonomous agents matching standard enterprise access management policies. - **Agent Registry**: Automatically tracks every agent deployed via the runtime, indexing their associated tools and callable backend services. - **Model Armor & Threat Management**: Provides real-time defenses against prompt injection, prevents accidental data exfiltration, and proactively surfaces threats. - **Agent Gateway**: Serves as the centralized, extensible control plane to regulate tool routing, agent-to-agent traffic, and enterprise policy boundaries.
---
[13:43](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=823s) Optimization: DeepMind Evals and Continuous Feedback Loops
The final pillar of Google Cloud's agent strategy centers on platform-level optimization. Rather than forcing organizations to assemble their own research divisions to measure agent reliability, Google embeds the methodologies and tooling developed by Google DeepMind directly into the platform. This provides built-in online and offline evaluation tools alongside continuous production monitoring.
Teams gain access to automated "auto-raters"—pre-packaged scoring models engineered for evaluating complex multi-step trajectories both during offline test cycles and against live production traffic. To further lower the barrier to setting up rigorous test suites, the platform introduces an evaluation expert skill. Developers can simply pass this skill to an autonomous coding agent, instructing it to configure comprehensive evaluations automatically.
Optimization extends directly into prompt refinement. Because the entire engineering workflow resides in a single pane of glass within the platform, developers can spot operational bottlenecks immediately. In production, delays are rarely caused by raw model inference alone; they typically stem from inefficient tool invocations, poor context management, or bloated prompt payloads. By co-locating build, governance, deployment, and optimization within one continuous feedback loop, agents steadily improve their performance, latency, and cost profiles over time without requiring third-party telemetry integrations.
> “When you build, governance, deploy, and optimize all in one system, you get a continuous feedback loop to really improve the agent over time.”
---
[15:12](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=912s) Agent Studio Console Walkthrough: Building, Agent Garden, and RAG
Aman Khan welcomes Lavi Nigam to the stage to demonstrate these features live within the Google Cloud Console. Lavi navigates into the newly reorganized Agent Studio interface (evolving from the foundational Vertex AI environment), which cleanly segments capabilities across agents, application builders, and media.
Lavi opens the Agent Builder to show that developers are no longer forced to write raw code to construct complex agent interactions. The interface provides a visual low-code/no-code UI designer where multi-agent workflows can be organized graphically. For teams seeking ready-made starting points, Lavi highlights Agent Garden. Paralleling Model Garden's catalog of foundation models, Agent Garden hosts a rich collection of pre-built agents sourced both directly from Google and from the wider ecosystem, ready to be deployed as-is or customized for tailored workflows.
For programmatic development, Lavi highlights the upgraded Agent Development Kit (ADK) support, pointing out native graph-based orchestration patterns and direct access to comprehensive documentation within the console. The studio also brings data retrieval and knowledge grounding natively into the build stage: - **Centralized MCP Servers**: A unified registry interface to manage and inspect Model Context Protocol (MCP) server connections, whether hosted internally or externally. - **Vector Search**: Direct index configuration and management capabilities for vector embeddings. - **RAG Engine**: Built-in corpus creation and retrieval-augmented generation pipelines. - **Enterprise Search**: Configurable search tooling spanning custom internal documents and rich media to give agents native document-grounding capabilities out of the box.
---
[18:14](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1094s) Inspecting Agent Engine: Tracing, Session Telemetry, and Playground
Transitioning from the build stage to production runtimes, Lavi dives into the Agent Engine—the managed runtime environment responsible for running, scaling, and observing deployed agents. Opening an agent project with historical test runs, Lavi showcases the detailed operational dashboard. The console surfaces immediate aggregates across active sessions, total model invocations (showing roughly 100 model calls in his test setup), evaluation runs, tool call volumes, and overall resource consumption.
Observability goes deeper than aggregate graphs through built-in distributed tracing. In production, pinpointing why an agent hallucinated, stalled, or called an incorrect tool requires exact execution breadcrumbs. Using the ADK, every interaction is assigned a unique session ID. Drilling down into an individual session ID exposes full trace and span views, allowing engineers to inspect the exact input payload, tool execution parameters, and model outputs at each discrete step of the execution graph.
Lavi demonstrates that the runtime tracks thousands of live user sessions with individual session identifiers for precise auditing. Finally, he opens the integrated testing Playground. Developers and testers do not need to rely exclusively on local CLI runs; they can test agent behavior interactively in the browser. The playground preserves conversation history and agent memories across conversational turns, providing a transparent sandbox to inspect how context retention and tool chaining behave in practice before pushing changes to production.
> “Traces are very important because if something goes wrong in your agent, you need to have a view of that.”
- **Aggregate Operations Metrics**: Real-time console metrics tracking total user sessions, evaluation benchmarks, model API calls, and tool call distributions. - **End-to-End Trace & Span Views**: Granular inspection tools tied to ADK session IDs, allowing engineers to isolate failures at specific node executions within an agent graph. - **Session Explorer**: Full visibility into individual user sessions across production workloads with trackable session IDs. - **Interactive Playground**: In-console testing suite supporting multi-turn dialogues, persistent agent memory inspection, and real-time tool invocation feedback.
[20:36](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1236s) Memory Banks, Centralized Governance, and Proactive Compliance
Lavi Nigam explains the critical role of state and memory management within the agent platform, pointing out that custom extraction logic or dedicated skills can feed directly into a centralized memory bank. Having a consolidated repository allows agents to preserve essential facts that users expect them to remember across disparate interactions, alongside streamlined access to historical conversation sessions. From memory management, Nigam pivots into the platform's governance capabilities, centered around the agent registry. This centralized dashboard exposes every deployed agent across the organization along with all active Model Context Protocol (MCP) servers and endpoints, creating an auditable inventory where every registered tool carries a unique, dedicated identifier.
```mermaid flowchart TD accTitle: Agent Governance and Gateways Architecture accDescr: Diagram showing how agent tools, MCP servers, policies, and gateways feed into proactive compliance and execution.
subgraph Registry["Agent Registry & Inventory"] A["Agent Registry (Unique Tool IDs)"] B["MCP Servers & Endpoints"] end
subgraph PolicyLayer["Policy & Access Control"] C["Central Policies (User & Org Level)"] D["Gateways & Access Paths"] end
subgraph SecurityLayer["Security & Runtime"] E["Model Enforcement by Default"] F["Proactive Compliance Engine"] end
A --> C B --> C C --> D D --> E E --> F ```
With centralized identity established across all tools and servers, enterprise administrators can define policy chains that restrict or grant access at either the individual user level or the broader organizational tier. Gateways reinforce these boundaries by defining explicit access paths, ensuring users cannot reach tools or endpoints beyond their authorization. Administrators can enforce and audit policies directly at these gateways, even enabling standard foundational models by default across specific agents. Security monitoring runs continuously in the background to surface compliance vulnerabilities ahead of time. Looking down at the interface showing failed checks, Nigam emphasizes that the platform catches configuration flaws early: “And this is again proactively agent platform is trying to figure out whether there has been issues or not.”
- The memory bank acts as a unified repository for user-requested persistent recall, custom memories, and extraction skills. - The agent registry catalogs all available platform agents and MCP servers, attaching specific unique IDs to each registered tool to form an enforceable governance chain. - Gateways define granular access paths, enforce compliance rules, and manage audit logging for sensitive endpoints. - Built-in security monitors proactively flag failed compliance checks directly in the management console before runtime failures occur.
---
[22:49](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1369s) Evaluation Monitoring and Gemini Enterprise as the Universal Front End
Turning to the optimization stage of the lifecycle, Nigam walks through the platform's evaluation suite. Teams can configure online monitors that continuously track agent execution across live traces and telemetry spans, inspecting execution status and identifying the exact conditions under which specific spans trigger. When baseline evaluations are not enough, developers can create custom metrics configured either through natural language prompts or by writing explicit evaluation code directly into the platform.
Nigam then showcases Gemini Enterprise as the conversational front door for organizational AI operations. Instead of fragmenting access across disparate internal portals, Gemini Enterprise provides a single unified workspace where business users interact with backend agents seamlessly. By typing an `@` mention directly into the prompt bar, a user can summon a specialized agent—such as a loan officer agent—which instantly loads with all predefined enterprise policies, access permissions, and guardrails enforced. As Nigam sums up: “So Gemini Enterprise becomes the front of everything that you do.” With the technical demonstration concluded, he hands the stage over to Thomas Menard and Gauthier Debuiche to share how L'Oréal has deployed the platform at global enterprise scale.
---
[24:26](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1466s) L'Oréal's Journey from Internal GPT to the Beauty Tech Platform
Thomas Menard takes the stage at Google Cloud Next for the third consecutive year to detail L'Oréal's rapid AI expansion. Highlighting L'Oréal's scale as the world's largest beauty company—selling 7 billion units annually across 150 countries, spanning 40 global brands, and operating as the fourth-largest advertiser globally—Menard explains that their AI journey began in December 2023 with the launch of an internal tool named L'Oréal GPT. While engaging 2,000 weekly active employees felt like an initial triumph, keeping the solution isolated in a silo proved unsustainable. By Next 2024, the team dismantled their monolithic backend, transforming L'Oréal GPT into modular, reusable AI microservices designed for internal software engineering teams.
```mermaid flowchart LR accTitle: L'Oréal AI Scaling Timeline accDescr: Timeline tracing L'Oréal's AI journey from December 2023 through Next 2026.
A["Dec 2023: L'Oréal GPT<br/>2,000 weekly users"] --> B["Next 2024: Reusable AI Services<br/>Decoupled internal backend"] B --> C["Sept 2025: Scale Phase<br/>30,000 weekly users<br/>50+ prod cases, 15M msgs/mo"] C --> D["Strategic Shift<br/>Make-to-Buy Decision<br/>Adopt Google Cloud Platform"] D --> E["Next 2026: Beauty Tech Platform<br/>41,000 weekly users<br/>30,000 zero-code agents"] ```
By September 2025, adoption surged to 30,000 weekly active users, over 50 enterprise use cases in production, and an average volume of 15 million messages passing through their AI services every month. Employees began generating zero-code agents organically, pushing their custom-built infrastructure to its limits. Menard candidly explains the strategic realization that followed: “Continuing to build bulletproof, enterprise grade technology until your home was no longer the smartest path forward.” L'Oréal made the strategic pivot from "make" to "buy," selecting Google Cloud's Agent platform as the core foundation for the L'Oréal Beauty Tech Platform, enabling their engineering talent to focus entirely on direct business value rather than foundational infrastructure plumbing.
By Next 2026, the metrics reflected massive organizational scale: - 41,000 weekly active users accessing L'Oréal GPT across global brands and regional entities. - 30,000 zero-code agents built and deployed directly by employees. - Complete backend migration onto Google Cloud's Agent Development Kit (ADK) and Agent Engine. - “We're not just ready for the moon,” Menard quips. “We already have the rocket and we are in flight.”
---
[27:42](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1662s) The Control Tower Architecture: Gateways, Tools, and Interoperability
Menard outlines the architecture of L'Oréal's Beauty Tech Platform, describing it as an enterprise control tower that governs every internal interaction. At the topmost layer sit L'Oréal's day-to-day business applications—both proprietary tools developed in-house and standard enterprise SaaS platforms like Salesforce, ServiceNow, and SAP SuccessFactors. Directly beneath these business interfaces lies the heart of the platform: a centralized gateway that intercepts, governs, and audits every model invocation, tool execution, and agent decision through built-in guardrails, ensuring that no action executes without strict human oversight.
```mermaid flowchart TD accTitle: L'Oréal Beauty Tech Platform Architecture accDescr: Layered architectural diagram of L'Oréal's Beauty Tech Platform showing business applications, governance gateway, development engines, and open protocols.
subgraph AppLayer["Business Applications"] A["In-House Apps"] B["Enterprise SaaS (Salesforce, ServiceNow, SuccessFactors)"] end
subgraph GatewayLayer["Centralized Gateway & Guardrails"] C["Unified Control Tower (Human Oversight & Policy Enforcement)"] end
subgraph CoreEngine["Tech Teams Development Stack"] D["ADK & Agent Engine"] E["Model Training & Tuning"] F["MCP Tooling & BigQuery Data Platform"] end
subgraph Ecosystem["Open Interoperability"] G["External SaaS Agents"] H["Third-Party Models (Anthropic)"] I["External MCP Servers via A2A & UCP"] end
AppLayer --> C C --> CoreEngine CoreEngine <--> Ecosystem ```
The gateway serves as the workbench where engineering teams train domain models, deploy agents using the ADK and Agent Engine, assemble custom tools via MCP, and ground reasoning in enterprise data housed primarily within Google Cloud BigQuery. Crucially, the platform rejects vendor lock-in by embracing open industry standards; external models such as Anthropic's Claude, SaaS vendor agents, and third-party MCP servers plug into the gateway using standard protocols like Agent-to-Agent (A2A), MCP, and Universal Commerce Protocol (UCP). Menard highlights their dual operational advantages: full observability, ensuring real-time visibility into every trace, and discoverability, which prevents duplicate effort across distributed global brands. “Think of it as a unified control tower at the top,” Menard summarizes, concluding that it delivers: “One platform, every agent, full control.”
---
[29:25](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1765s) The Five Pillars of Enterprise Agent Adoption
Gauthier Debuiche addresses the broader operational challenge of enterprise transformation, asserting that deploying sophisticated technology is meaningless if employees and developers fail to embrace it. He poses the fundamental question facing enterprise IT leaders: “The real question is, how do you move an entire company into the agent era?” To answer this, L'Oréal established five foundational pillars divided between technology and people. The technical foundation relies on the Agent Toolkit and the API Gateway, while organizational momentum is sustained by a human stack consisting of a Center of Excellence, a Governance Task Force, and an internal developer community.
```mermaid flowchart TD accTitle: L'Oréal Five Pillars of Agent Adoption accDescr: Structural breakdown of L'Oréal's technical and human adoption pillars.
subgraph AdoptionFramework["Enterprise Agent Adoption"] subgraph TechStack["Technical Foundation"] T1["Agent Toolkit (ADK on GCP)"] T2["API Gateway (Discover, Reuse, Govern)"] end subgraph HumanStack["Human Foundation"] H1["Center of Excellence"] H2["Governance Task Force"] H3["Internal Community"] end end ```
By anchoring their Agent Toolkit directly to the Google Cloud Platform stack, L'Oréal removed their central platform team from the critical development path. When Google ships updates, documentation, or new engine features, L'Oréal's developers gain immediate access without waiting for internal middleware rewrites. This approach standardizes development around open industry patterns, allowing L'Oréal to onboard external engineering talent who are immediately productive on day one.
Debuiche frames the central API Gateway around three core imperatives: - **Discover:** Models, agents, and safety guardrails are registered in a single shared catalog, allowing any global team to locate existing enterprise components instantly. - **Reuse:** Adherence to standard communication protocols ensures that assets built across disparate business units and technical platforms remain modular and pluggable. - **Govern:** Real-time monitoring tracks token consumption, enforces deployment validation gates, and drives massive economies of scale across foundational model usage.
Walking through a typical implementation workflow, Debuiche illustrates how an engineering squad begins on the left side of their ecosystem by identifying vetted models, specialized agents, and MCP tools exposed in the gateway. The team selects their desired foundational model, pulls relevant domain agents, connects them using Google Cloud's ADK as the orchestration backbone, and hooks into managed GCP services to handle session state and persistent memory.
[32:50](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1970s) The Human Stack: Center of Excellence and Community Scaling
Deploying memory and Retrieval-Augmented Generation (RAG) directly through Agent Engine eliminates technical overhead and operational bottlenecks. Development teams no longer need to maintain bespoke proprietary frameworks or sit in a queue waiting for assistance from a central engineering team; instead, they immediately gain access to frontier models, internal and external tools, and reusable agents to accelerate their development cycles. However, scaling across an enterprise requires pairing the technical layer with a well-structured "human stack." At the center sits a dedicated Center of Excellence (CoE) consisting of platform specialists who provide global tools, production-ready starter packs, and expert support, while directly managing relationships with external technology providers such as Anthropic and Google.
```mermaid flowchart TD accTitle: The Enterprise Human Stack Architecture accDescr: Flow showing how the Center of Excellence, the Lineup relay network, and decentralized business teams collaborate to build governed AI agents.
subgraph Governance ["Central Strategy & Governance"] CoE["Center of Excellence (CoE)<br/>• Starter packs & expert support<br/>• Vendor management (Google, Anthropic)<br/>• Architecture, Security, Trust & Privacy"] end
subgraph Community ["Decentralized Community Layer"] Lineup["The Lineup (AI Champions)<br/>• Technical problem-solvers<br/>• Business domain experts<br/>• Relay network across divisions"] end
subgraph Execution ["Federated Business & IT Teams"] IT["IT Teams"] Biz["Business Units"] Upskill["Upskilling & AI Adoption<br/>'Leave no one behind'"] end
CoE -->|"Standards & tools"| Lineup Lineup -->|"Enablement & mentorship"| IT Lineup -->|"Use-case discovery"| Biz Biz --- Upskill IT --- Upskill ```
This operating model marks a profound organizational evolution. Rather than acting as a centralized bottleneck delivering discrete services for other departments, the central team pivots toward creating an environment where any team can build their own solutions. As the speaker explains: “The key shift is that we went from building services for everyone to empowering everyone to build.” Governance adapts simultaneously: because autonomous agents introduce unfamiliar operational risks, oversight shifts from manually inspecting the output of a few isolated teams to enforcing global, enterprise-wide standards covering architecture, cybersecurity, trustworthy AI, data privacy, and statutory compliance.
To scale these standards across all distributed IT groups, the organization relies on an internal network called "The Lineup." Composed of hand-picked AI champions embedded throughout different business units, these ambassadors combine deep technical aptitude with localized business domain knowledge. They serve as an active relay network bridging the traditional divide between IT departments and business operations, ensuring that employees across the company can upskill, grasp advanced AI concepts, and contribute directly to digital initiatives with the explicit cultural goal to leave no one behind.
- Core platform benefits: Eliminates proprietary framework maintenance, bypasses centralized ticket queues, and offers self-service access to models, tools, and agents. - CoE responsibilities: Curating starter packs, providing technical guidance, and managing external vendor relations with partners like Google and Anthropic. - Governance checkpoints: Enterprise architecture conformance, cybersecurity policies, trustworthy AI guidelines, data privacy controls, and legal/regulatory compliance. - The Lineup network: Hand-selected hybrid champions serving as regional relays to bridge technical implementation with departmental business value.
---
[35:20](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=2120s) The Platform Web App: An Agent-Driven Front Door for the Enterprise
While the Google Cloud Console offers an extensive environment for dedicated cloud developers, scaling adoption across an entire business requires an interface accessible to non-specialists. To meet this need, the team developed a dedicated platform web application designed to act as the enterprise's central front door. This portal integrates a discovery catalog for components exposed through the API gateway, tailored onboarding and training paths, internal compliance guidelines, centralized monitoring dashboards, and an automated feed highlighting developments across the wider agentic AI landscape.
```mermaid flowchart LR accTitle: Platform Web App Capabilities accDescr: Overview of core modules available to enterprise users inside the unified Platform Web App portal.
Portal["Platform Web App<br/>(Front Door)"]
subgraph Modules ["Portal Functional Areas"] Cat["Component Catalog<br/>Gateway APIs & Tools"] Agents["Agent Directory<br/>Internal & External"] Models["Model Comparison<br/>Side-by-side Benchmarks"] Guard["Shared Guardrails<br/>Cross-case Policies"] Dash["Monitoring & Feeds<br/>Global Dashboards & AI News"] end
Portal --> Cat Portal --> Agents Portal --> Models Portal --> Guard Portal --> Dash ```
The underlying architectural design of the web application is recursive: the system does not merely host agents; it runs on an agentic architecture itself. As the speaker highlights: “We don't just build agents with the platform, but agents are at its core the platform.” Demonstrating the live user interface, the speaker walks through the unified catalog, which exposes reusable assets alongside a directory of internal and third-party agents ready to be embedded into novel workflows.
The demonstration highlights how users can inspect specific integration details—such as tool definitions, Model Context Protocol (MCP) connectors, and configuration parameters—to link them seamlessly into target architectures. The portal also features a model comparison utility that lets builders evaluate foundation models side by side to pick the ideal engine for their latency, cost, and task requirements. Finally, a centralized repository of shared guardrails allows teams to reuse standardized safety, privacy, and operational rules across completely distinct projects, establishing consistent enterprise defenses without reinventing safeguards for every deployment.
- Front door capabilities: Central component catalog, structured learning paths, internal procedural documentation, operational telemetry, and agent news. - Core architecture: Self-hosted on agent workflows rather than conventional static service architectures. - Catalog features: Detailed specifications for agents, external tools, MCP connectivity, and orchestration hooks. - Model evaluation: Side-by-side model comparison tools to match workload requirements with optimal model capabilities. - Shared guardrails: Centrally maintained governance policies distributed across multiple independent business use cases.
---
[37:27](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=2247s) Closing Reflections and Resources for the Agent Journey
Returning to the stage to conclude the presentation, Google Cloud host Aman Khan reflects on the customer's organizational transformation, remarking: “That line that you had earlier really resonated with me, from going from building services to enabling teams to be able to build products.” He emphasizes that this shift perfectly captures the ultimate goal of Google Cloud's modern agent infrastructure: removing architectural friction so platform teams can transition from low-leverage bespoke builders into high-leverage organizational enablers.
Aman wraps up the session by directing attendees toward concrete next steps displayed via on-screen QR codes. One link routes directly to the core Google Cloud agent platform documentation to help developers initiate their first builds, while another provides access to an enterprise architectural guidebook detailing how to implement an enablement-first platform model within large organizations. In summarizing the broader advancements across the platform, Aman emphasizes that this generation of tooling centers on three pillars: deep ecosystem interoperability, cross-functional ease of use so multi-disciplinary teams can collaborate in a single shared environment, and granular enterprise customizability. These capabilities unify the lifecycle—allowing companies to build, scale, govern, and optimize intelligent agents end to end on one platform—before inviting attendees to return in future years to share what they have created.
- Recommended resources: Official Google Cloud agent platform documentation and an enterprise enablement guidebook for engineering leaders. - Strategic pillars: Deeper ecosystem interoperability, intuitive cross-functional usability, and tailored enterprise customization. - Lifecycle coverage: End-to-end support spanning agent creation, operational scaling, regulatory governance, and continuous performance optimization.
## Notable quotes > [32:50](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=1970s) The key shift is that we went from building services for everyone to empowering everyone to build. — Gauthier Debuiche
> [08:50](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=530s) Without memory, your agent has no idea what happened yesterday, what the user prefers, what failed last time. — Aman Khan
> [00:13](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=13s) Everyone can get in a Toyota Camry and drive it. It's a reliable car. It's stable, runs well. That's traditional software development. But with agents, we're building race cars. We're building Formula One race cars. — Aman Khan
> [10:39](https://www.youtube.com/watch?v=FxnjRYo3fpU&t=639s) We think governance should span from prototype to production, and it includes the perimeters and boundaries to define what your agent can and cannot do in your environment. — Aman Khan
## Mentioned Google Cloud, Aman Khan, Lavi Nigam, Gauthier Debuiche, Thomas Menard, Gemini Enterprise, Agent Development Kit (ADK), Agent Engine, Agent CLI, Agent Builder, Agent Studio, Agent Garden, Agent Registry, Agent Gateway, Agent Identity, Model Armor, Sessions and Memory Bank, Google DeepMind, Model Context Protocol (MCP), Vertex AI, L'Oréal, L'Oréal GPT, BigQuery, Anthropic, Salesforce, ServiceNow, SAP SuccessFactors, Universal Commerce Protocol (UCP), Agent-to-Agent (A2A)
## Video description Explore the next evolution of Google Cloud’s agent platform, designed to empower developers and enterprises to build, scale, and govern sophisticated AI agents. Discover our new, unified Gemini Enterprise Agent Platform Agent Builder, featuring a streamlined UX and a no-code/low-code Agent Designer to simplify the creation of complex, multi-agent workflows. Find out how our new Agent Registry, coupled with the agent marketplace, enables organizations to securely curate and distribute reusable components. Learn how we’re delivering enterprise-grade governance and quality at scale with a unified governance layer, new agent management capabilities, advanced observability with time-travel debugging, an integrated evaluation suite, and a managed simulation platform to ensure your agents are secure, reliable, and continuously improving. From a richer Agent Development Kit (ADK) with expanded language support to native agent-to-agent communication and a secure code execution sandbox, Google Cloud provides a comprehensive ecosystem for the entire agent life cycle.
Watch more Google Cloud Next 2026 Sessions → https://goo.gle/gcloud-next-2026 Subscribe to Google Cloud Tech → https://goo.gle/GoogleCloudTech
Speakers: Aman Khan, Lavi Nigam, Gauthier Debuiche, Thomas Menard
BRK2-093 #GoogleCloudNext
[Source](https://www.youtube.com/watch?v=FxnjRYo3fpU)