What's new in Google Cloud's agent platform

Source: https://www.youtube.com/watch?v=FxnjRYo3fpU
Video ID: FxnjRYo3fpU

---

Overview

The session walks through the latest evolution of Google Cloud’s Agent Platform, explaining how it moves from prototype‑level chatbots to production‑grade, autonomous agents that can run at scale across an enterprise. Aman Khan (product manager) and Lavi (DevRel) outline new capabilities, showcase early customer adopters, and demonstrate how the platform integrates with Gemini Enterprise to provide a unified, secure stack for building, deploying, governing, and optimizing AI agents.

New Features & Announcements

• Graph‑based orchestration – Model real business processes with branches, loops, and conditional paths.
• Agent collaboration – Decompose complex tasks across specialized agents instead of a monolithic one.
• Batch & event‑driven workflows – Enable agents to react to real‑time system events, not just user prompts.
• Native skill definitions in ADK – Define a skill once and reuse it across all agents.
• Agent CLI + built‑in skills – One‑stop command‑line tool for scaffolding, evaluating, deploying, and observing agents.
• Sub‑second cold‑start runtime – Faster start‑up for high‑throughput production workloads.
• Bring‑your‑own‑container support – Run agents in custom runtimes for strict compliance or performance needs.
• 7‑day unattended single‑plan execution – Individual agents can operate continuously for up to a week without human intervention.
• Bidirectional streaming – Low‑latency, real‑time interaction between agents and users/applications.
• Sessions & Memory Bank (GA) – Persistent, framework‑agnostic memory that retains context, preferences, and feedback across conversations.
• Code‑execution sandbox (GA) – Secure environment for agents to run arbitrary code or interact with GUIs.
• Agent Identity (GA) – Granular, auditable permission management for agents, like user IAM controls.
• Agent Registry (GA) – Central inventory of all deployed agents, their tools, and service access.
• Model Armor – Real‑time protection against prompt injection and data leakage.
• Proactive Threat Management – Continuous monitoring for anomalous agent behavior.
• Agent Gateway (GA) – Control plane for routing, securing, and governing all agent traffic with extensible policies.

Topics Covered

• Historical context & vision – Recap of the Agent Development Kit (ADK) launch, the shift from chatbot‑centric demos to full‑fledged autonomous agents.
• Analogy of race cars vs. sedans – Highlights the need for safety guardrails when deploying powerful “race‑car” agents in production.
• Integration with Gemini Enterprise – Gemini provides the front‑end experience for users while the Agent Platform supplies the developer‑focused back‑end stack (runtime, registry, gateway, observability, etc.).
• Three pillars of the platform – Ecosystem & interoperability, ease of use/collaboration, and deep customizability for enterprise data and tools.
• ADK enhancements – New graph orchestration, collaboration primitives, event‑driven triggers, and reusable skill definitions.
• Developer experience upgrades – Introduction of the Agent CLI that automates scaffolding, testing, deployment, and observability, usable both from IDE extensions and directly in terminals.
• Production scalability – Improvements to runtime latency, container flexibility, long‑running agent support, and streaming capabilities.
• Memory & context handling – Sessions and a persistent memory bank enable agents to retain state, preferences, and feedback over time.
• Sandboxing & real‑world execution – Secure code execution environments and GUI interaction sandboxes turn agents from answerers into doers.
• Governance as a first‑class layer – End‑to‑end identity, registry, model armor, threat management, and the Agent Gateway deliver compliance, security, and auditability without stitching disparate tools.
• Optimization & evaluation – Leverages DeepMind research tools for online/offline evals, continuous monitoring, and automated performance tuning.
• Customer showcase – Brief mentions of early adopters (L’Oréal, Gautier, Thomas) using the platform for production workflows.

Key Takeaways

• The Agent Platform is now a vertically integrated stack that takes an agent from idea to production without rebuilding plumbing each time.
• New graph‑based orchestration and collaboration primitives let developers model real business processes and split work among specialized agents.
• The Agent CLI dramatically simplifies the end‑to‑end workflow—scaffold, test, deploy, monitor—from a single command line.
• Runtime enhancements (sub‑second cold starts, BYOC, 7‑day autonomous runs, bidirectional streaming) make the platform ready for large‑scale, latency‑sensitive use cases.
• Persistent sessions and memory banks give agents long‑term context, turning them into truly autonomous assistants.
• Governance is baked in, with GA features for identity, registry, model armor, threat management, and a unified Agent Gateway, removing the need for numerous third‑party security tools.
• Optimization tools from DeepMind provide enterprise teams with research‑grade evaluation without requiring in‑house AI experts.

Notable Quotes

• “Everyone can get in a Toyota Camry and drive it… but with agents we’re building Formula 1 race cars.” – emphasizing the power and responsibility of autonomous agents.
• “Agents shouldn’t start from scratch with every conversation. Without memory, your agent has no idea what happened yesterday.” – underscoring the importance of persistent context.
• “Governance should span from prototype to production… we think of it as an agent alignment problem.” – framing governance as an integral, not an afterthought, component.

---

Podcast Script

JORDAN: Welcome to Episode 11 of SlackCasts by PodSlacker — where AI does the watching so you can do the listening. If you want a richer experience with today's episode, visit PodSlacker dot com slash SlackCasts — you'll find a written summary, key frame moments from the video, and an interactive AI chat to explore the topic as deep as you like. Now let's get into it.

MIKE: Jordan, the new Agent Platform preview feels like a whole new operating system for autonomous AI. Let’s start by grounding the audience: how does this evolution differ from the ADK launch a year ago?

JORDAN: The original ADK was essentially a sandbox for building single‑agent chatbots—think RAG‑style assistants. The latest platform adds a production‑grade stack: runtime, registry, gateway, identity, observability, and evaluation—all baked into Google Cloud. It’s the shift from a prototype‑only mindset to a vertically integrated, enterprise‑ready environment.

MIKE: That vertical integration is key for enterprises that can’t afford a patchwork of tools. I liked the “race‑car vs. Camry” analogy. How does the platform keep those high‑performance agents safely on the track?

JORDAN: Governance is baked in from day one. Features like Model Armor, proactive threat management, and the Agent Gateway act as guardrails, preventing prompt injection, data leakage, and unauthorized tool access. It’s not an after‑the‑fact add‑on; it’s woven into the runtime and control plane.

MIKE: Speaking of the control plane, the Agent Gateway sounds like a central traffic manager. What does it actually do?

JORDAN: It’s a policy‑driven ingress for all agent traffic. You can define granular routing rules, enforce TLS, and apply per‑agent tool permissions. Because it’s extensible, you can plug in custom auth providers or audit loggers without rearchitecting your services.

MIKE: Let’s drill into the developer experience. The new Agent CLI seems to be a major productivity boost. How does it differ from the older ADK tooling?

JORDAN: The CLI consolidates scaffolding, unit testing, deployment, and observability into a single command set. It can be invoked directly from a terminal or called by IDE plugins like Cloud Code. Under the hood it leverages ADK definitions, so the same skill metadata you write is automatically available for deployment and monitoring.

MIKE: And the “native skill definitions” you mentioned—what problem does that solve?

JORDAN: Previously you duplicated skill logic across agents. Now you declare a skill once in the ADK manifest, and any agent that imports the manifest gains that capability. It enforces versioning, reduces code churn, and ensures consistent policy enforcement across the fleet.

MIKE: That dovetails nicely with the collaboration primitives. How does agent collaboration actually work in practice?

JORDAN: The platform introduces a graph‑based orchestration engine. You model business processes as DAGs with branches, loops, and conditional nodes. Each node can invoke a specialized agent—say, one for invoicing and another for inventory check—allowing you to decompose complex workflows rather than stuffing everything into a monolith.

MIKE: So you can have both batch and event‑driven triggers. Does that mean agents can listen to Pub/Sub events directly?

JORDAN: Exactly. You can attach a trigger to a Cloud Pub/Sub topic, Cloud Scheduler cron, or even a Cloud Storage notification. When the event fires, the orchestration engine spawns the appropriate agent graph, enabling real‑time reactive automation.

MIKE: Real‑time brings us to the bidirectional streaming capability. Why is that important for latency‑sensitive use cases?

JORDAN: Traditional REST‑style calls incur round‑trip delays, which is unacceptable for, say, a live sales assistant or a robotics controller. Bidirectional streaming opens a gRPC channel where the user and agent exchange messages continuously, achieving sub‑second interaction latency and enabling incremental result delivery.

MIKE: Speaking of latency, sub‑second cold‑starts were highlighted. How does the runtime achieve that?

JORDAN: The runtime now pre‑warms container images using a lightweight sandbox and leverages Google's hyper‑scale compute fabric. Combined with the BYOC (bring‑your‑own‑container) model, you can tune the base image for fast load, ensuring that even on scale‑out events the latency stays under a second.

MIKE: BYOC also hints at compliance concerns. How does the platform let customers satisfy strict data residency or security standards?

JORDAN: You can ship a custom container that contains your own vetted runtime, libraries, and even hardened OS patches. The platform still enforces identity and model armor at the gateway, but you retain full control over the execution environment, which is crucial for regulated industries.

MIKE: That leads to the 7‑day unattended execution. How realistic is it to leave an agent running autonomously for a week?

JORDAN: The engine now supports single‑plan execution without human intervention for up to 168 hours. It combines automated health checks, checkpointing of state to Cloud Storage, and periodic token refreshes. The memory bank persists context across that interval, so the agent can continue a long‑running workflow—think a nightly data reconciliation job.

MIKE: Memory is another first‑class component now. What does the Sessions & Memory Bank actually store?

JORDAN: Sessions are lightweight identifiers that tie a series of interactions together. The Memory Bank is a durable KV store where you can persist user preferences, past actions, or feedback signals. It’s framework‑agnostic, so you can embed custom fields—like a risk score—that surface in downstream prompts.

MIKE: That solves the classic “agent forgets what you told it yesterday” problem. How about the code‑execution sandbox? Is that safe for arbitrary code?

JORDAN: The sandbox runs in an isolated gVisor environment with strict syscalls whitelisting. It supports Python, Node, and Java runtimes out of the box, and you can request additional runtimes via BYOC. It also enforces time and memory limits, and all I/O is logged for audit.

MIKE: The GUI interaction sandbox seems novel. What does that enable?

JORDAN: Agents can drive a virtual desktop via VNC‑like protocols, manipulating UI elements to complete tasks that lack APIs—think legacy ERP screens. The sandbox records each action, so you get a replayable audit trail.

MIKE: On the governance side, Agent Identity is GA now. How does that differ from standard IAM?

JORDAN: Agent Identity extends Cloud IAM to non‑human principals. You can assign roles like “data‑reader” or “tool‑executor” directly to an agent’s service account, and the Gateway enforces those at runtime. It gives you per‑agent, per‑tool auditability.

MIKE: And the Agent Registry provides visibility across the enterprise. Is that just a list, or does it surface usage metrics?

JORDAN: It aggregates metadata from the runtime: version, deployed tools, last invocation timestamps, and health status. You can query it via Cloud Asset Inventory to generate compliance reports or cost‑analysis dashboards.

MIKE: Model Armor was mentioned as a real‑time protection layer. How does it intervene on a prompt?

JORDAN: It runs a lightweight transformer that scans incoming prompts for injection patterns, sanitizes them, and can reject or rewrite malicious inputs before they hit the model. The policy is configurable per agent, allowing you to strike a balance between flexibility and security.

MIKE: The proactive threat management component sounds like a SIEM for agents. What signals does it monitor?

JORDAN: It watches for anomalous tool calls, sudden spikes in token usage, repeated failed executions, and outbound network attempts. When thresholds are breached, it can auto‑quarantine the agent, generate alerts, and surface a root‑cause analysis in Cloud Logging.

MIKE: Let’s not forget optimization. How do DeepMind’s evaluation tools integrate with the platform?

JORDAN: The platform ships a suite of offline and online eval frameworks—e.g., reward modeling, A/B testing pipelines, and continuous performance dashboards. You can plug in custom reward functions, and the system will automatically run regression tests against your baseline, surfacing drift alerts.

MIKE: That reduces the need for in‑house AI research teams. Finally, any real‑world customer signals?

JORDAN: Early adopters like L’Oréal are using the platform to automate inventory tagging, while the logistics firm Gautier runs multi‑agent supply‑chain orchestration with sub‑second latency. Thomas, a fintech player, leverages the memory bank to personalize compliance workflows across millions of customers.

MIKE: Those use cases illustrate the move from “agent as a chatbot” to “agent as an autonomous business engine.” Any final advice for teams thinking of jumping in?

JORDAN: Start small—use the CLI to scaffold a single‑skill agent, enable the memory bank, then iterate toward graph orchestration. Leverage the built‑in governance primitives early; retrofitting security is far more costly.

MIKE: And keep an eye on the optimization loop—use the DeepMind evals to keep performance and safety in lockstep as you scale.

JORDAN: That's a wrap on today's SlackCast. Head over to PodSlacker dot com slash SlackCasts for the written summary, visual key moments, and an AI chat to dive even deeper into today's topic. Until next time — slack off smarter.