Google has significantly expanded its developer resources for building advanced AI agents with the release of thirteen detailed demonstrations showcasing the capabilities of its Gemini Enterprise Agent Platform. Introduced earlier this year, the platform aims to provide a holistic environment for creating, deploying, managing, and refining sophisticated AI agents. The newly released demos, accessible through interactive codelabs and tutorials, are designed to offer practical, hands-on learning experiences for developers looking to leverage the platform’s full potential.
The core of this initiative lies in empowering developers by abstracting complex infrastructure and operational concerns. A key highlight is the Agents CLI, a command-line interface that integrates seamlessly with popular coding agents such as Antigravity, Claude Code, and Codex. Once installed, the CLI equips these agents with seven specialized skills, enabling them to understand and execute tasks related to the Agent Development Kit (ADK) and the broader Agent Platform. Developers can now describe their desired agent functionalities in plain English, and their coding agent will autonomously handle the scaffolding, evaluation, deployment, and monitoring processes, all within their familiar coding environment.
This release underscores Google’s commitment to democratizing AI agent development, moving beyond theoretical concepts to provide actionable pathways for real-world applications. The demos span the entire agent lifecycle, from initial build and data integration to scaling for production, implementing robust governance, and continuous optimization.
Building the Foundation: Crafting Your First AI Agents
The initial set of demos focuses on the foundational aspects of agent development using the code-first ADK. These resources are structured to guide developers from the ground up, introducing core concepts and architectural patterns.
1. Your On-Ramp to ADK: Building Your First Agent
The "ADK Foundation codelab" serves as the essential starting point for newcomers. It meticulously guides users through setting up their development environment, defining a basic conversational agent powered by Gemini, configuring its parameters, and testing its functionality through both command-line interfaces and web-based user interfaces. This codelab is crucial for anyone new to the ADK, providing a solid understanding of the initial steps involved in agent creation.
2. Event-Driven Approval Agent with Human-in-the-Loop
A particularly comprehensive demonstration is the "ambient expense agent codelab," which illustrates the Agent Platform in action. This demo involves building a corporate expense approval agent. Expenses falling below a defined threshold are automatically approved using standard Python logic. For expenses exceeding this threshold, a multi-stage process is initiated: a pre-LLM security screen handles Personally Identifiable Information (PII) redaction and prompt-injection defense, followed by a Gemini compliance analysis. Finally, the request enters a human-in-the-loop review stage before final approval. This agent is designed to be mounted behind FastAPI and triggered by Pub/Sub events, with its performance evaluated using an LLM-as-judge approach. The complexity and real-world applicability of this agent make it a recurring example throughout the "Scale" and "Govern" sections.
3. Connecting Agents to Data: The Model Context Protocol (MCP)
The "MCP codelab" introduces the Model Context Protocol, an open standard designed to facilitate reusable tools that allow Gemini to interact with diverse data sources. Developers learn to build MCP tools that enable Gemini to query BigQuery databases, search through files, and invoke external APIs. The open nature of MCP ensures that tools developed under this protocol are interoperable across different vendors and frameworks, fostering a more connected AI ecosystem.
4. Dynamic Frontend Development with Agent-to-UI (A2UI)
Recognizing the importance of intuitive user experiences, the "A2UI codelab" demonstrates how to create agents that render dynamic, visual user interfaces. This involves building agents capable of generating real interface components such as layouts, charts, and interactive menus. These UI elements update in real-time as the conversation progresses, with the agent dynamically assembling the necessary interface elements on the fly, tailored to the user’s current needs.
Scaling for Production: From Prototype to Enterprise Deployment
Once agents are built, the challenge shifts to scaling them to handle production-level traffic, manage memory efficiently, and orchestrate complex workflows. The next set of demos addresses these critical aspects.
5. Deploying Stateful Data Science Agents to Agent Runtime
The "Stateful Data Science Agent codelab" guides developers through the process of building a BigQuery agent. This agent is designed to retain user preferences across sessions using a feature called Memory Bank. The demonstration then walks through deploying this agent directly to Agent Runtime, Google’s managed environment for running AI agents. This deployment process automatically handles underlying infrastructure, scaling, and session management, significantly simplifying the operational overhead for developers.
6. Building Long-Running Agents with Pause and Resume Capabilities
Enterprise workflows often extend beyond the duration of a single user interaction, potentially spanning days or weeks. The accompanying "tutorial" tackles this challenge by outlining architectural patterns for building agents that can reliably operate for extended periods. It details three key patterns: durable state machines for maintaining workflow integrity, event-driven handling of idle periods, and checkpoint-and-resume mechanisms for persistent sessions. An example of an onboarding coordinator agent demonstrates how these patterns enable agents to survive container restarts and seamlessly resume their tasks without losing context.
7. Production Deployment of the Ambient Expense Agent via Agents CLI
Building on the earlier "ambient expense agent" demo, the "Deploy to Agent Runtime codelab" focuses on taking this agent to a production environment. Using the Agents CLI, developers scaffold their deployment configuration, perform a dry run for preview, and then deploy the agent live. Upon deployment, several integrations occur automatically: Cloud Trace, Cloud Logging, and BigQuery Agent Analytics are enabled, and the agent is registered in Agent Registry, making it discoverable across the organization immediately after going live.
8. Integrating Production Agents with Real-World Frontends
The "frontend codelab" brings together various components to create a complete enterprise architecture. This demo involves building a manager dashboard deployed on Cloud Run. This dashboard connects to Agent Runtime via an OIDC-authenticated Pub/Sub pipeline, granting managers the ability to resume paused human-in-the-loop sessions directly from their web browsers. This integration effectively ties the expense agent and its deployment into a cohesive, end-to-end solution.
Governing AI Agents: Ensuring Security and Control
As AI agents become more prevalent in enterprise settings, robust governance mechanisms are essential to manage access, track endpoints, and filter traffic effectively.
9. Securing the Agent Lifecycle from Development
The "Secure Agentic Coding codelab" emphasizes a proactive approach to security, starting from the initial development phase. It demonstrates how to build a shopping assistant agent using test-driven development (TDD), integrate a custom STRIDE threat model, and implement a Semgrep pre-commit hook. A PreToolUse gate is configured to prevent risky actions before execution. A deliberate attempt to introduce a hardcoded API key is caught and fixed by the agent as soon as the hook is triggered, showcasing the effectiveness of these security measures.
10. Granular Access Control with Agent Gateway
The "Agent Gateway codelab" focuses on runtime governance, providing a comprehensive stack for securing agent interactions. This demo involves deploying a multi-tool ADK agent on Agent Runtime, which communicates with MCP servers on Cloud Run through Agent Gateway. Each agent is assigned a unique identity with end-to-end mutual Transport Layer Security (mTLS). All outbound calls are authenticated via Identity-Aware Proxy (IAP) and authorized by Identity and Access Management (IAM). Furthermore, Model Armor is employed to inspect all content for prompt injection vulnerabilities and data leakage, offering a complete, production-grade governance solution.
Optimizing AI Agents: Continuous Improvement and Performance Tuning
Deploying an agent is merely the beginning of its lifecycle. The true challenge lies in ensuring that modifications, such as prompt tweaks, lead to genuine improvements without inadvertently causing regressions in other functionalities. The final set of demos addresses this crucial aspect of continuous optimization.
11. Driving Agent Quality with an Evaluation Flywheel
The "Driving the Agent Quality Flywheel" tutorial introduces a structured, five-stage evaluation process that can be executed directly from a developer’s coding agent. This flywheel begins with data preparation, drawing from OpenTelemetry (OTel) traces, manually created test cases, or synthesized scenarios. It proceeds to run inference, grade the outputs using Google’s adaptive AutoRaters (developed in partnership with DeepMind and based on principles used for evaluating Google’s own models), analyze clusters of failures, and finally, execute targeted optimizations. Developers can simply articulate their desired measurement criteria in plain language, and their coding agent will manage the rest of the process.
12. Cross-Language Multi-Agent Pipelines with Agent-to-Agent (A2A)
In large enterprises, diverse teams often develop agents using different programming languages. The "Build Cross-Language Multi-Agent Team" tutorial addresses this by demonstrating a contract compliance pipeline. This pipeline involves a Python-based agent that extracts contract terms using Gemini, and a Go-based agent that validates these terms against corporate policies. These two services communicate via the Agent-to-Agent (A2A) protocol and are orchestrated by ADK. The tutorial also introduces the RemoteA2aAgent, which allows any A2A-compliant service to be treated as a local sub-agent with minimal code.
13. Orchestrating Agents Across Frameworks: CrewAI, LangGraph, A2A, and ADK
Recognizing that production teams rarely standardize on a single agent framework, the "Scale Agents Across Frameworks" codelab showcases how to orchestrate agents across multiple popular frameworks. This demo details an ADK control room that delegates planning to a LangGraph state machine. The state machine, in turn, dispatches tasks to a CrewAI execution crew. All these components are interconnected via the A2A protocol. This architecture ensures that if any step in the process fails, the control room can automatically replan and re-execute the tasks, ensuring resilience and continuous operation.
Getting Started with the Gemini Enterprise Agent Platform
For developers looking for a rapid overview of the entire agent development lifecycle, a 10-minute walkthrough video is available. Alternatively, developers can directly install the Agents CLI and integrate it with their preferred coding agent. The Google Cloud Console provides a dedicated entry point for the Agent Platform, enabling developers to begin building their AI agents today. This comprehensive suite of resources signals Google’s strategic push to empower businesses with advanced AI capabilities through accessible and robust agent development tools. The platform’s focus on the end-to-end lifecycle addresses critical industry needs for speed, scalability, security, and continuous improvement in AI agent deployment.
