Google Cloud Unifies Agent Platform as L'Oréal Deploys 30,000 Bots

What's new in Google Cloud's agent platform — Google Cloud Tech

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)

Reading summary

Google Cloud is integrating its agent development frameworks, managed runtimes, and governance controls into a unified stack designed to bridge enterprise adoption hurdles and move beyond basic retrieval-augmented generation chatbots into autonomous, production-grade business execution. Bridging Enterprise Friction with Unified Architecture (0:13) Aman Khan, Group Product Manager for agent governance, observes that while underlying artificial intelligence models accelerate exponentially, enterprise deployment is impeded by compliance, security reviews, and organizational friction. Comparing standard software to a reliable passenger vehicle and autonomous enterprise agents to high-performance race cars, Khan argues that unconstrained open frameworks pose major operational risks if deployed without enterprise guardrails. To remove the handoff friction between engineering teams and end-user applications, Google Cloud combines Gemini Enterprise—serving as the front-door interface for knowledge workers—with an underlying agent platform that unifies developer runtimes, component registries, enterprise identity, and Google Cloud infrastructure like the AI Hypercomputer. Developer Tooling, Persistent Memory, and Autonomous Runtimes (6:34) Google upgraded its open-source Agent Development Kit (ADK) to support graph-based orchestration, cyclical loops, inter-agent collaboration, event-driven triggers, and reusable cross-enterprise skills. A newly introduced Agent CLI functions both as a terminal utility and as an instruction set for coding assistants such as Gemini Code Assist to scaffold, evaluate, and deploy projects. For cloud operations, the Agent Engine runtime now delivers subsecond cold starts, bring-your-own-container support, and bidirectional streaming for multimodal audio. The runtime also introduces Sessions and Memory Bank to resolve conversational amnesia by maintaining cross-session state and feedback, allows agents to execute single autonomous plans for up to seven continuous days without human prompts, and moves secure code execution sandboxes with graphical desktop interface interaction into General Availability. End-to-End Governance and DeepMind-Driven Optimization (10:39) To monitor and protect autonomous systems, Google Cloud made Agent Identity generally available, granting agents auditable Role-Based Access Control identical to human staff. The Agent Registry inventories deployed agents, tools, and Model Context Protocol (MCP) servers with unique identifiers, while Model Armor intercepts prompt injection and data exfiltration in real time. Operational traffic is regulated through the Agent Gateway, which enforces tool routing policies and organizational access boundaries. For post-deployment tuning, the platform embeds Google DeepMind evaluation methodologies, offering automated scoring models ('auto-raters') for multi-step trajectories across both offline test runs and live traffic. Granular distributed tracing links unique session IDs to execution node inputs, tool parameters, and model outputs directly within the Agent Studio console. L'Oréal's Operational Pivot and the Human Stack (24:26) L'Oréal executives Thomas Menard and Gauthier Debuiche detailed their evolution from an isolated internal chatbot ('L'Oréal GPT' launched in December 2023 with 2,000 weekly users) to a centralized Beauty Tech Platform built on Google Cloud's ADK and Agent Engine. Facing scaling bottlenecks by late 2025—when processing 15 million monthly messages across 30,000 weekly active users—L'Oréal shifted from internal development to a managed platform model. By 2026, the company reported 41,000 weekly active users and 30,000 employee-built zero-code agents governed by a centralized API gateway supporting open protocols like MCP and Agent-to-Agent (A2A). Debuiche explained that technical tools succeed only when accompanied by an enterprise adoption framework split across technology and people. Alongside the GCP-backed toolkit and governance gateway, L'Oréal established a Center of Excellence for architectural standards and starter packs, paired with 'The Lineup'—a decentralized internal network of hybrid AI champions embedded across divisions. This operational structure shifted the central IT team from acting as a development bottleneck building point services into an enablement engine allowing non-technical business units to construct their own governed workflows. Google Cloud's agent ecosystem aims to transform central IT teams from service bottlenecks into enablers by providing unified build, runtime, and governance tools. However, successful enterprise-wide deployment depends equally on non-technical adoption, cross-functional upskilling networks, and open architectural standards to prevent vendor lock-in across expanding multi-agent fleets.

Source quotes

[32:50] Gauthier Debuiche: The key shift is that we went from building services for everyone to empowering everyone to build. [8:50] Aman Khan: Without memory, your agent has no idea what happened yesterday, what the user prefers, what failed last time. [0:13] Aman Khan: 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. [10:39] Aman Khan: 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.

Original transcript

[0:13] Welcome, everyone. [0:15] Wow, this is a big room. [0:18] We're so excited to be here today and share what's [0:21] new in agent platform and do a deeper dive on what we just [0:24] announced in the keynote, and show a little bit about some [0:28] of how some of our customers are adopting the agent [0:30] platform already. [0:32] My name is Iman Khan. [0:33] I'm a group product manager on the agent platform team focusing [0:37] on agent governance. [0:38] And I'm joined by lavie on our DevRel team, who's [0:40] going to be doing a demo of some of what we talked about [0:43] earlier today, as well as some amazing partners, Gauthier [0:47] and Thomas, who are going to be showing how they're already [0:50] adopting the agent platform for production workflows today. [0:55] So I want us to Zoom out really quick before we [0:57] jump into all of this and think about how exactly one year ago [1:02] you learned about ADK. [1:04] We showed you all Agent Engine. [1:06] We wowed you with a bunch of demos [1:08] like the autonomous plant store. [1:10] And we're really excited about what [1:12] was really possible with the agentic AI Cloud [1:15] that we launched last year. [1:16] But since then, we've actually made a number of improvements. [1:20] In November when we launched the basics of additions [1:23] of governance and the basics of deployment [1:26] to allow you to go from prototype to production. [1:31] And it feels things are changing again. [1:34] This should feel familiar. [1:35] Your competitors are moving faster, [1:39] the industry is moving at an exponential rate, [1:42] and technology isn't moving linear anymore. [1:44] It's advancing exponentially. [1:46] But everyone's organization is still [1:48] in this sort of logarithmic trend. [1:50] The curve flattens out. [1:52] Think organizational challenges, compliance, security, [1:57] getting your whole org bought in on a single stack. [2:00] That's why you have to think about step functions [2:03] in how you operate. [2:06] And that's what we're going to be talking about. [2:08] How the agent platform enables the step [2:10] function improvements to how you can [2:12] adopt agentic AI applications. [2:15] So a year ago everything was sort of centered [2:18] around chatbots. [2:20] RAG chat applications. [2:22] Every demo was a chatbot. [2:24] But now it's pretty clear that agents [2:27] are the engine of our business. [2:29] Think of it this way. [2:30] I heard this analogy earlier this week. [2:33] And it's really stuck with me. [2:35] Everyone can get in a Toyota Camry and drive it. [2:37] It's a reliable car. [2:39] It's stable, runs well. [2:41] That's traditional software development. [2:43] But with agents, we're building race cars. [2:46] We're building Formula One race cars. [2:48] These are highly sophisticated instruments [2:51] that can do real work in your business. [2:53] But you can't just run a race car in YOLO mode. [2:56] You wouldn't put an electric car in self-driving mode and just [2:59] floor it. [3:00] Actually, a quick question for folks [3:01] in the room how many people have actually tried [3:04] opencore and built something with opencore? [3:07] How many folks have heard of opencore at least. [3:09] OK, there we go. [3:11] Think of it this way. [3:13] What would you say if someone came up to you and said, [3:15] hey, maybe we should put opencore in our business [3:18] and let it start running and see what happens. [3:22] Yeah, that's kind of a crazy proposition. [3:26] But what if it wasn't that crazy. [3:28] What if it actually worked. [3:31] Well, you need guardrails to make sure [3:32] that when you're building agents, [3:34] you're doing it in a way that's integrated with an end [3:37] to end stack with context in mind from the start. [3:40] And that's what we're here to do today. [3:42] We're going to show you how to have an end to end ability [3:45] with building agents using the agent [3:47] platform to enable this shift. [3:51] We're combining Gemini enterprise [3:53] with the agent platform in one story, one narrative, and one [3:56] seamless experience. [3:58] Gemini app enterprise is the doorstep for everyone [4:01] in your organization. [4:02] To get started with AI, an agent platform [4:06] is where your developers build. [4:08] What this means is that your business's processes [4:12] stop being disconnected. [4:13] Agents and data can actually flow through your enterprise [4:17] without friction. [4:18] There's no handoff tax between what your developers are [4:21] building on the back end, and what [4:23] your employees and customers actually use at the top. [4:28] The services that your users interact [4:30] with, like the Gemini app custom Maps, things [4:32] that partners may build, and then in the middle, the agent [4:35] platform, which is where your developers actually live. [4:39] The runtime registry, gateway, identity, observability [4:42] and evals. [4:43] All of that sits on top of Google Cloud's AI stack. [4:47] The Hypercomputer, agentic, Data Cloud, and agent defense. [4:51] This foundation is what gives you [4:53] a real edge in performance and security [4:56] because you don't need to stitch together five [4:58] different vendors to get this. [5:00] Now let's Zoom in to the agent platform layer. [5:03] Agent platform is a vertically integrated stack [5:06] that lets you move from basic idea [5:08] to a production ready agent, without having to rebuild [5:12] the underlying plumbing. [5:13] Every single time you start a new project with platform, [5:17] you get best in class support with open source native [5:20] tooling to build agents the way you want to build them. [5:24] Our goal centers on three areas. [5:27] First, deeper investment in a richer, richer ecosystem, [5:31] and interoperability. [5:32] Second, ease of use to get started so that your entire team [5:36] can collaborate in one place. [5:38] And third, customizability. [5:40] Because we know that off the shelf agents don't just work [5:43] have to hook them up to your data, your tools, [5:46] and run within the bounds of your business. [5:49] So that's the core foundation for your developers, your AI [5:52] engineers, your AI product managers [5:54] to get started with building agents. [5:56] Agent platform lets you build, scale, govern, [5:59] and optimize agents that can scale infinitely in the Cloud. [6:03] Now we're going to get into how we'll spend time [6:05] on each part of the stack. [6:07] What's new and why it matters. [6:08] And then we'll talk you through this [6:10] from the perspective of a developer that's planning agents [6:13] in your business this year. [6:14] So I want you to put yourself in that mindset. [6:17] What are the agents that you're thinking [6:19] about in this next half that can really move [6:22] the needle for your business. [6:23] And let's see what it would take to actually ship [6:26] that with the agent platform. [6:28] If there's any parts that really stand out. [6:30] Come and find one of us for a deeper dive [6:32] after this presentation. [6:34] Let's start from the beginning. [6:36] Building a.d.k has been our foundation [6:39] to help you get started with building. [6:40] And this year, we've made some major advancements [6:42] to make it even more powerful and extensible. [6:45] As an agent harness framework. [6:47] Google uses SDK widely throughout the business, [6:50] from bets in different parts of alphabet [6:52] to core products and services you've probably [6:55] interacted with just today. [6:57] It's designed to help you scale from the smallest agent [7:00] to the most complex multi-agent system, [7:03] and to enable interoperability. [7:06] A few exciting launches we're excited to announce. [7:09] Graph based orchestration means you can model real business [7:12] processes, real work branches and loops, [7:15] and conditional paths. [7:17] You have agent collaboration, which [7:18] means you can decompose complex problems across specialized [7:22] agents instead of trying to cram everything into one [7:25] single monolithic agent. [7:26] And then you have batch and event driven workflows [7:29] so that agents can actually react to things in real time [7:32] that are happening in your system versus just reacting [7:34] when a human tells them to. [7:36] We also are excited to share that we have native skill [7:39] definitions in ADK, which means you [7:41] can define a skill once and reuse it everywhere else. [7:46] ADK is being used in your business. [7:49] Getting started is also about to get a whole lot easier. [7:52] We're excited to launch a new agent CLI and skills [7:56] for building, evaluating and deploying AI agents on Google [8:00] Cloud agent CLI is built with SDK and our agent runtime [8:05] in mind, so that knowledge of our entire platform [8:08] is actually baked into these skills and CLIs [8:11] that you're getting to use. [8:12] So if you're just getting started with building an agent, [8:15] the CLI can handle everything around it, the scaffolding, [8:18] evaluation, deployment and observability. [8:20] And it works in two ways. [8:22] You can either just pass the CLI and skills to the agents [8:26] that you're already using Cloud Code, Gemini, CLI, Codex [8:30] or others. [8:31] And the coding agent can make the right decisions. [8:33] Or if you're not using a coding agent, [8:35] you can just run the CLI commands directly [8:37] from your terminal and every command works standalone. [8:40] Personally, I found it incredibly helpful [8:43] to help get my agents stood up in our environment, [8:45] and we're just getting started with the out of the box [8:47] primitives for building on top of the platform. [8:50] Next, let's talk about scale. [8:53] Building agents is step one, but running agents [8:56] in confidence in production is the critical next step. [9:00] This starts with deploying your agent [9:02] to a runtime that enables you to serve thousands, or even [9:05] millions of users out of the box with platform. [9:09] We're making the runtime significantly more powerful [9:12] with subsecond cold starts, and we've added the capability [9:16] to bring your own container for ultimate flexibility for how [9:19] you want to run those agents. [9:21] We also know that agents don't just [9:22] run out of the box on a task for a long duration [9:25] without some serious configuration, which [9:27] is why we're excited to share that the Agent Engine now [9:30] also supports individual agents to be able to run [9:33] on a single plan without any human intervention [9:36] for up to seven days. [9:38] And that's alongside our already supported [9:41] advanced multi-agent orchestration. [9:44] Plus, we're adding bidirectional streaming [9:46] to handle more complex real time interactions like that Gemini [9:50] Flash demo you saw earlier for low latency streaming [9:54] interactions. [9:56] Agents shouldn't start from scratch with every conversation. [10:00] Without memory, your agent has no idea [10:02] what happened yesterday, what the user prefers, [10:05] what failed last time. [10:06] And now with sessions and memory, bank agents, [10:09] get persistent memory so that they get smarter over time [10:12] by retaining context, recalling preferences, and learning [10:16] over time so that you can build an intelligence layer that [10:20] compounds the session services. [10:22] Also framework agnostic, so you can [10:24] define custom session fields to capture signals [10:26] like user feedback. [10:29] Agents are most powerful when they can act in the real world, [10:32] so we're excited to share a number of sandbox features [10:35] in GA. [10:37] Code execution sandboxes lets agents [10:39] run in the real world on real world tasks, [10:42] while bringing your own container support [10:44] allows you to define and use custom environments when [10:47] you have strict requirements, agents [10:49] can now interact with GUIs duties [10:51] so that they can use the computer. [10:53] Use sandbox as well. [10:55] Context makes agents smarter and sandboxes [10:58] make agents more useful. [11:00] Together, you go from a chatbot that answers questions [11:03] to an autonomous system that remembers [11:06] what it's supposed to be doing. [11:07] How to do it and can actually go and execute tasks. [11:12] Next, let's talk about governance. [11:14] We're thinking about governance as an end [11:16] to end part of our stack. [11:18] Your governance story shouldn't be pieces [11:20] that you're going to pull together [11:21] from different vendors or legacy services you already have. [11:24] You really need to think about governance [11:27] as a critical part of the stack that [11:29] works through the runtime, all the way [11:31] through to optimization evals. [11:33] Observability agent platform provides that foundation [11:36] for trust for every agent that you deploy. [11:39] And we're excited to share that the agent identity is now in GA. [11:44] You can manage permissions just like you [11:46] would any other user in your organization, [11:48] with granular controls to ensure every action is authorized [11:52] and auditable. [11:53] Whether your chief compliance officer or a risk officer [11:56] or just a developer, you've probably [11:58] asked yourself, what are all of these different agents that I [12:01] have across my business in the first place. [12:04] Agent registry helps you answer that question [12:06] by listing all the agents that have been registered [12:09] automatically via our agent runtime or the agent registry [12:13] system. [12:14] When agents are registered, you're [12:16] able to Siebel Tools those agents have access [12:18] to what services they can call. [12:21] And it's just really this is a great starting point [12:23] to really see how agents are being [12:24] used across your enterprise. [12:27] On top of that, we've made some serious enhancements [12:30] to how you can secure your agents in your environment using [12:33] Model Armor, which can block prompt injection. [12:36] Prevent data leaks in real time. [12:39] You need to be able to monitor your agents [12:40] interactions and actions, and that's [12:42] why we've launched proactive threat management directly [12:45] integrated within the platform. [12:47] And we're also launching gateway, [12:49] which is a control plane for Enterprise Agents. [12:52] The agent gateway simplifies how you secure and govern [12:56] all of your agent traffic, so you [12:57] can set granular controls like access to specific tools. [13:01] And if you need something custom, it's fully extensible. [13:04] So we're really thinking about governance as an end [13:06] to end story. [13:07] It's not bolted on as an afterthought. [13:09] We think governance should span from prototype to production, [13:12] and it includes the perimeters and boundaries to define what [13:16] your agent can and cannot do in your environment. [13:18] Today we're launching those foundational components [13:20] with batteries included, but our vision [13:22] is that governance is architecturally integrated [13:25] throughout the platform, and our goal [13:27] is to build features so that the users of our platform [13:30] don't need to be experts in governance to ship agents [13:32] that organizations can trust. [13:34] It's really we think of it as an agent alignment problem. [13:38] So we're excited to launch this foundation, [13:39] and we're going to use it to build out a full governance [13:42] story going forward. [13:43] All right. [13:43] We're rounding out here. [13:44] We're going to get into this last pillar optimization. [13:48] Now, when it comes to optimization, [13:50] here's what makes our approach different. [13:52] You get the benefit of the research of DeepMind [13:55] and how they build evals with a specialized set of tools [13:59] for online and offline evals and continuous monitoring, [14:02] without having to have an army of researchers [14:05] inside your own business. [14:06] We provide you with that army of researchers throughout the agent [14:10] platform, because Google has invested deeply in how [14:13] to evaluate our own agents. [14:15] And you're getting the benefits of that investment [14:17] because it's the same product we're [14:19] shipping auto raters, which are out of the box [14:21] scores for offline and online evals, [14:24] as well as an evaluation expert skill [14:27] to make evaluation with the coding agent even [14:29] simpler by passing them that skill and saying, hey, set up [14:32] evals for me in the system. [14:34] We're also shipping optimization, [14:36] which is based on a prompt optimization. [14:39] With platform optimization, you're [14:42] getting a single pane of glass because your whole team is [14:45] already in the agent platform. [14:47] The things slowing down. [14:48] Your agents today aren't the model [14:50] its tool calls its context. [14:53] And when you build, governance, deploy, and optimize [14:55] all in one system, you get a continuous feedback loop [14:59] to really improve the agent over time. [15:02] That means you get production quality agents that get better [15:05] over time without needing to stitch together [15:08] a bunch of different vendors and tools [15:09] to get this out of the box. [15:12] All right, that was a lot of ground. [15:14] And with that, I'd like to welcome up lavie to the stage, [15:16] and he's going to take us through a demo of the agent [15:18] platform. [15:29] All right, let's switch to the demo. [15:33] Perfect so Amin did talk about a lot of things. [15:36] What we're going to do is we're going [15:37] to see live what is available to you [15:39] right now in your Cloud Console. [15:41] I'm going to go to one of my projects [15:45] and this is the Agent Studio. [15:46] So this is the new Studio that you see. [15:47] So Vertex AI is now sort of called [15:50] as Agent Studio where you have agents, [15:52] you have app builders and media. [15:54] As you can see can actually add agents [15:56] here directly whatever agents that you've built. [15:59] So I'll start with this. [16:00] The next thing I want to show is that you can actually create [16:02] your new agents right away. [16:04] So the moment I do this, you can see that there's a UI now, [16:09] and you don't have to write code if you don't want to [16:11] but if you wish to can actually just do the UI designer [16:14] part of that. [16:16] What we also have is a bunch of different agents [16:18] which are available as Agent Garden. [16:20] So if you have already used Model Garden [16:22] that what it allows you to do is access different kinds of models [16:26] beyond Gemini app very similarly, [16:28] Agent Garden gives you access to different kinds [16:30] of agents, which are either built by Google [16:32] or somebody outside of that. [16:34] So you can actually choose a bunch of these different agents [16:37] right away and then build over that, or just use it as is. [16:40] As you can see, we have so many different options [16:43] available here, which you can use and get started. [16:46] We also have something which is SDK 2.0. [16:48] Aman was mentioning that we have introduced [16:50] many of the new features, especially the graph based [16:53] workflows that you can actually now build in CDK. [16:55] So you can actually use that and see how you can build over this. [17:02] Oops sorry. [17:04] So the next is the SDK. [17:05] So this is where you actually again get [17:08] a lot of access to ECE SDK docs right in your platform. [17:12] And this is where you should be able to start [17:14] with any of the documentations which are required. [17:16] The other thing which is very important [17:18] and I'll come back to this at the other stage, which [17:21] is at the agent registry part. [17:24] But you now have a centralized access [17:26] where you can actually see all the MCP servers that you have, [17:29] whether it's your server outside, [17:31] and you can have a central location where you can see this. [17:34] You also get vector search and tag engine. [17:36] So this is, again, something that we had before. [17:38] But now it all comes under the build stage. [17:41] So you have all of these accessible right to you. [17:44] And you can define your vector search. [17:45] You can create new indexes if you wish to. [17:48] All the options that are available to you. [17:50] You can also create drag engine if you wish to do that, [17:53] and you can create corpus around it. [17:55] And then the last one is the search. [17:57] So search is very important because again, a lot of search [18:00] that you want to do, a lot of agents [18:02] that you want to build need inbuilt capability for them [18:04] to search through your documents. [18:06] And that's what search sort of gives you [18:08] access to which is you can create a custom search [18:10] or you can do a media search as per that. [18:14] The next thing which is very important, [18:16] this is one of my favorite, which [18:17] is the Agent Engine part of it. [18:19] So once you're done building, whether by design or Bytecode, [18:23] one of the very important thing that you want to do [18:26] is you want to use the Agent Engine to scale your agents. [18:29] And we have new runtimes which are there. [18:31] The way this looks like is that you have all the agents that you [18:34] see here. [18:35] So these are a bunch of agents that I was experimenting. [18:37] And you can see those agents here once I click on this, [18:42] the best part you can actually see is let me select this. [18:48] Oops, sorry. [18:59] I'm going to select one of the old agents [19:01] that I was playing with. [19:03] And this is where you can actually see a bunch of metrics. [19:06] So for example you get the overall view [19:08] as to how many sessions were there. [19:10] You see the evaluations. [19:11] You see how many model calls were made. [19:14] You also see the tools that are there. [19:16] For example, I did close to 100 model calls on this. [19:20] You also get to see the tools. [19:22] So this is again all the tools calls [19:23] that happen in your agent and the overall usage as well. [19:27] So this is, again, very important [19:28] because you need that visibility into what your agent has done. [19:32] And this sort of deployment section [19:35] gives you the complete view of that. [19:37] The other very important things are the traces. [19:40] Traces are very important because if something [19:42] goes wrong in your agent, you need to have a view of that. [19:46] The way that happens is if you're using ADK, [19:48] you have session IDs, and these sessions IDs are very important. [19:51] So the moment you click on this, you actually [19:53] get to see all the sessions and all that has happened. [19:57] And you can then individually go and see [19:58] the trace view or the span view, just to get to the part [20:03] where things have not worked out. [20:05] The other important thing is you have access to sessions. [20:08] So if your users are using and you have thousands of sessions, [20:11] you can actually see all individual sessions [20:13] because now they have IDs which are exposed to you. [20:16] The best part is you also have a playground. [20:18] So it's not that you just do a local testing. [20:21] You actually have a way where you can test your agents right [20:24] away in the playground. [20:26] So just to show you a couple of examples, if you open, [20:29] you can actually see all the stuff [20:31] that somebody has been playing or you have played with this. [20:34] In that sense, it also has memories now. [20:36] So if you have written your own memories [20:38] or you have written skills or logic which [20:40] can extract these memories, you will see that here as well. [20:44] Going to the next, which is the memory bank. [20:46] This is again, very important because you [20:49] do want to have memories in your agents in terms of things [20:53] which the user wants you to remember. [20:55] And now you have a centralized place [20:57] where you can store all of these things in a simple way. [21:01] Again, session I have shown you, which is very simple, all [21:05] the access to the sessions. [21:07] The next thing which is very important [21:08] is the governance part, which is where you have access [21:11] to all the agent registry. [21:13] So this is where I wanted to show you that. [21:15] Now you have a centralized view where [21:17] you have access to all the agents [21:19] which are available in the agent platform. [21:21] You also have all the MCP servers. [21:23] So at least you now get to have a centralized place where [21:26] you can govern them. [21:27] The most important part is that you [21:29] get to see how many tools are registered inside it. [21:32] And there's a specific ID which is associated, [21:34] which means you can create a governance chain around that. [21:38] Similarly, you have endpoints. [21:40] And you can add these MCP servers and all of those things. [21:43] Same with policies again, because now [21:45] you have all of this as a central ID [21:47] level, which means that you can actually add new policies. [21:50] And you can define the access by the users [21:54] or by the organization at the higher level. [21:57] Similarly, you have gateways. [21:58] Gateways are very important because again, you [22:00] would want to restrict certain things for certain users. [22:03] You do not want them to access certain things which [22:05] are not required. [22:06] So you can define different gateways. [22:08] You can define different kinds of access path. [22:11] You can enforce policies, you can audit policies [22:13] and all of those things. [22:15] One of the cool things that you can do now [22:17] is you can enable the model by default. [22:19] So you can select the agent and then [22:21] you can enable those model things. [22:24] We also have security access right inside this. [22:27] And one of the coolest thing that you get to see, [22:29] which is what naaman was showing you, [22:30] is that now you pre preemptively get all the compliance issues [22:34] that are there in your agent. [22:35] So if you notice on the bottom, you'll [22:37] see that there are a lot of failed issues that has happened. [22:41] And this is again proactively agent platform [22:45] is trying to figure out whether there has been issues or not. [22:49] The last part is the evaluation, which is part of the optimize. [22:53] What you see here is different kinds of evaluation [22:56] that your models go through. [22:58] And you can do a couple of things. [23:00] You can actually do online monitors, [23:01] which essentially means that you can define these logics. [23:04] And these logics will keep on monitoring each and every part [23:06] of your agents through the span and the traces [23:08] that I was showing you. [23:10] And then you can actually see the status of them. [23:12] You can see the traces where they have been triggered. [23:14] Or you can define your metrics. [23:16] So if you go to create metric, you now [23:18] have a way where you can define metric either through prompt [23:21] or through code. [23:22] So can actually define a code and say that, hey, this [23:24] is what I want you to do this. [23:26] So this is the part of evaluation. [23:28] Now, one last thing that I want to show you [23:30] is the Gemini enterprise. [23:33] So Gemini enterprise becomes the front of everything that you do. [23:37] So this is pretty much like saying [23:39] you have Gemini as a front end of everything [23:41] that you do in the back end. [23:42] The way this looks is very interesting [23:44] because now you can actually just oops. [23:52] So this is how you see all the agents. [23:55] So for example, if I do, at the rate [23:56] you can see my loan agent is there [23:58] and all your users can directly access these agents. [24:01] And these agents can then follow all the policies, [24:04] all the guardrails and all of those things. [24:06] And that's all. [24:07] With that, I'm going to invite Thomas and Gauthier to talk [24:10] about how they are using platform [24:12] to do some amazing stuff and scale things at L'Oreal, please. [24:26] So hello everyone. [24:27] It's so good to be there. [24:29] For the third time in a row. [24:30] Speaking about AI at L'Oreal. [24:32] So you have to know that the journey have [24:35] started in AI thanks to Google. [24:37] But before jumping into what we do with Google. [24:40] Just a few words about who we are at L'Oreal for the one [24:43] we don't know us. [24:45] We are the world's largest beauty company in the world, [24:48] selling 7 billion units every year through 150 countries [24:53] into through 40 global brands. [24:57] Also, we are the fourth largest advertiser worldwide. [25:01] So you can imagine that we are the leader [25:04] in the world of beauty, but we are also the expert [25:07] in the world of tech, able to sees what starts [25:11] and to demonstrate to that. [25:12] Tell me. [25:13] Let me tell you our story. [25:16] Back in December, 23, like many of you in this room, [25:19] we took our first step into the AI era. [25:23] We launched our GPT, a secure internal AI solution [25:29] built for our employees. [25:31] And honestly, we were proud. [25:34] 2000 weekly users felt like a real achievement [25:37] at the beginning, but we moved fast, [25:41] and we quickly realized that keeping this solution siloed [25:44] won't be enough. [25:46] If we truly wanted to scale AI across the company, [25:50] we needed to open our own made backend to the tech [25:53] teams, giving them the building blocks [25:56] to develop their own use cases in a unified and scalable way. [26:01] So we transform GPT into a set of reusable AI services. [26:06] And that was our story of next 24. [26:09] And those two small projects, they grew up very fast. [26:13] And by September 25, we had already 30,000 weekly users [26:17] on L'Oreal and over 50 use cases in prod through the AI services, [26:23] sending approximately 15 million messages every month [26:27] to the platform. [26:29] And we started to have some 0 code agents developed [26:32] by the employees through GPT. [26:35] We had built some. [26:37] We had built something real, something big. [26:40] But with that scale came r-truth, continuing [26:44] to build bulletproof, enterprise grade [26:46] technology until your home was no longer the smartest path [26:51] forward. [26:52] So we made a bold strategic decision from make to buy. [26:57] We chose to leverage the best tech available, the Google Cloud [27:01] platform that you just saw just before to create the L'Oreal [27:05] beauty tech platform. [27:07] Not because we couldn't build this, [27:09] but because partnering with the best in class technology [27:13] meant that we could focus on what truly matters for us. [27:16] Creating value for. [27:19] And today, here at next 26, the results speak for themselves [27:24] 41,000 weekly users on L'Oreal, GPT, [27:27] and 30,000 0 code agents developed by the employees [27:32] through this platform. [27:33] All that running on ADK and jet engine. [27:37] We're not just ready for the moon. [27:38] We already have the rocket and we are in flight. [27:42] So what exactly do we do. [27:45] At its core, the beauty tech platform is simple. [27:48] The single place where tech teams makes and buys [27:52] agents, leveraging everything you saw from Amazon Levy. [27:57] Think of it as a unified control tower at the top. [28:01] Our everyday business applications. [28:04] The one that we make, but also the one [28:06] that we buy such as Salesforce, ServiceNow, [28:09] success factor and so on. [28:11] All connected and all benefiting from what [28:14] sits underneath the heart of the platform [28:17] is the gateway, the layer that governs [28:20] every model, every tool, every agent with built in guardrails. [28:25] Nothing goes through without control, [28:27] and human oversight is the place for the tech teams [28:32] to train models to build and deploy agents [28:35] with ADKAR, agent jet engine and so on to build tools [28:39] with the MCP, and also to bring the knowledge that is mainly [28:44] plugged on our data platform on BigQuery, but not only. [28:49] And critically, this platform is open external agents [28:52] from our Sas vendors, external models, [28:56] such as the Anthropic ones, external MCP servers. [29:00] They are all plugged seamlessly by leveraging [29:03] standard protocols such as a two way MCP, UCP, and so on. [29:09] And we have also two final superpowers the observability. [29:13] So we always know what's happening, the discoverability. [29:17] So every team can find and reuse what already exists. [29:21] One platform, every agent, full control. [29:25] But Gauthier, can you tell us a bit more about what do we [29:29] do to empower the team. [29:31] Because having the platform and the technology is not enough. [29:35] And what do we need to bring that to life. [29:38] Thank you. [29:39] Thank you Tom. [29:41] So yes, the agent platform is where we build agents. [29:44] But building agents is only part of the challenge. [29:48] The real question is, how do you move an entire company [29:53] into the agent era. [29:55] For that, we need five pillars. [29:57] On the technical side, we have the agent toolkit and the API [30:02] gateway. [30:04] But the tech alone won't drive adoption. [30:07] We also need a human stack with it. [30:10] So we have a center of excellence, a governance task [30:14] force, and a community. [30:16] So let's start with the tech. [30:20] The agent toolkit is the bread and butter of the platform. [30:26] So developers must have everything [30:28] they need to build to scale and to monitor their agents. [30:34] We chose the GCP stack. [30:36] Why Because of everything we saw earlier. [30:39] Because it's the best stack. [30:41] But here's the real magic. [30:43] The platform evolves without us. [30:47] With Azure demand expanding. [30:50] We can't be on the critical path. [30:53] So Google DevOps improves document services. [30:58] While our team can focus on bringing value, [31:03] they can have access instantly to the latest features. [31:07] They can upskill, but they can also [31:10] learn on industry standards. [31:12] On our side, what is interesting is [31:14] that we can hire people that are ready from day one. [31:21] So now that the developer can build agents, [31:25] we need to make sure we can handle all these. [31:30] And how do we reuse components at scale. [31:34] That's what the gateway is for. [31:37] Think of it in three words. [31:40] Discover reuse govern so. [31:43] Discover models. [31:46] Agents guardrails. [31:48] All registered in a single place. [31:51] Every team can find what already exists across the group. [31:56] Then reuse based on standard protocols. [32:00] We ensure we can reuse everything [32:02] we built from all our business and technical platforms [32:07] and governance. [32:08] We monitor usage in real time, we validate what gets deployed, [32:14] and we drive economies of scales, especially [32:17] in terms of model usage. [32:21] So let's see at a typical project. [32:25] So on the left, you have a growing ecosystem of agents, [32:30] tools, and models made available through the gateway [32:35] as a use case. [32:36] You pick the model you need. [32:39] Keep your agents and you wire them together [32:42] with ADK as the backbone. [32:45] Then you plug. [32:46] You plug the GCP services to handle sessions. [32:50] Memory RAG you deploy with Agent Engine and you're good to go. [32:55] No proprietary framework to maintain. [32:58] No waiting for the central team. [33:00] You get access to the latest models, [33:03] internal and external tools, and agents to build faster. [33:09] It's that simple. [33:11] Then, as I was saying, we need a human stack. [33:15] So starting with a center of excellence, this is our team. [33:19] So we are the platform experts providing global tools [33:23] like starter packs, expert supports. [33:26] And we also manage the relationship [33:28] with providers like Anthropic and Google. [33:32] The key shift is that we went from building services [33:35] for everyone to empowering everyone to build. [33:39] That's a fundamental change in how we operate, [33:43] and it's the only way to scale to the entire company. [33:47] Then governance has to evolve, too, [33:51] as agencies bring new complexities, [33:54] and we move from overseeing the work of a few teams [33:57] to ensuring that every I builds across the company meets [34:03] our standards in terms of enterprise [34:06] architecture, cybersecurity, trustworthy AI, data [34:11] privacy, and legal compliance. [34:15] OK, so we have the global team. [34:18] And now how do we scale to all the IT teams across the company. [34:22] That's where the community comes in. [34:25] We created what we call the lineup. [34:28] These are hand-picked AI champions, champions [34:32] across the organization. [34:34] They are both technical experts that [34:37] can tackle really complex use cases, and business [34:41] experts with deep knowledge of their business and organization. [34:46] They are really relay network to make [34:49] sure we cover all the companies and then learning with AI. [34:55] The wall between IT and business is fading. [35:01] It's now easier than ever to upskill, [35:03] to learn advanced concepts, to bring value, [35:07] and that is something we want to embrace. [35:10] AI is not only for it. [35:12] We encourage everyone to learn and contribute. [35:17] The goal. [35:18] Let no one behind. [35:20] To make all of this accessible, we [35:22] need to go beyond the GCP Console. [35:25] It's great for developers, but we need something for everyone [35:30] and that's why we are building the platform web app. [35:35] It will be the front door to the entire platform, [35:38] with a catalog to discover every component [35:42] available in the gateway. [35:43] Easy access to training path, our internal processes, [35:48] global monitoring dashboards and a feed [35:51] with the latest news from the Atlantic world. [35:55] But here was here is what's the most exciting. [35:59] We the we don't just build agents with the platform, [36:04] but agents are at its core the platform. [36:08] It runs on agents. [36:10] And here's a first look of what it looks like. [36:17] So in the platform you have access [36:19] to the catalog the principal items [36:24] but also resources that will come. [36:27] You have access to the agents both internal and external, that [36:31] can be reused in your use case. [36:33] And same thing. [36:36] You can see the details of every single Mc, [36:40] the tools available and how to connect them in your use case. [36:45] And you also have access to the models here. [36:48] We really want to be able to compare to really choose [36:52] the right one for the usage. [36:54] And finally the guardrails. [36:57] So these are guardrails we want to share across multiple use [37:01] cases. [37:03] So just before finishing I would like [37:06] to give a big thank you to all the teams working [37:10] on the platform. [37:12] And yeah big big kudos to the teams. [37:17] Thank you. [37:19] Thank you. [37:27] That was great. [37:28] That line that you had earlier really resonated with me, [37:31] from going from building services [37:33] to enabling teams to be able to build products. [37:36] That was really amazing. [37:37] Well, if you're looking for what to do after this, [37:40] there's a couple of quick QR codes you can scan. [37:42] On the left is a resource for being [37:44] able to check out the latest agent platform and get started. [37:48] It takes you directly to our docs, [37:50] and then there's also of guidebook [37:53] that we have on learning how platform can enable your team. [37:57] So to bring it all together this year with platform, [38:00] you're getting a deeper ecosystem investments [38:03] in interoperability, ease of use so your entire team can work [38:07] in one place, and customizability so [38:10] that those agents actually work for your business build, scale, [38:13] govern, optimize end to end in one platform, [38:16] and we can't wait to see what you all will build and maybe [38:19] come back again next year. [38:20] Show us how things have changed again.