Earlier this year, Google introduced the Gemini Enterprise Agent Platform, a comprehensive solution designed to streamline the development, deployment, and management of sophisticated AI agents. Today, the company is significantly enhancing developer accessibility to this platform by releasing a detailed collection of 13 interactive demos. These demos are meticulously crafted to illustrate core concepts, practical patterns, and robust architectural designs that developers can immediately integrate into their projects. The announcement signifies a crucial step in democratizing advanced AI agent development, moving beyond theoretical concepts to tangible, actionable workflows.
A key innovation accompanying these demos is the Agents CLI. This command-line interface is designed to integrate seamlessly with existing coding agents, such as Claude Code, Codex, and others, providing them with seven specialized skills. These skills empower the coding agent to become an expert in the ADK (Agent Development Kit) and the Agent Platform itself. Developers can now articulate their desired agent functionalities in natural language, and their coding agent will automatically handle the scaffolding, evaluation, deployment, and monitoring processes, all within their preferred development environment, eliminating the need to switch contexts. This approach aims to dramatically reduce the learning curve and accelerate the development lifecycle for complex AI applications.
The release of these demos and the Agents CLI underscores Google’s commitment to fostering an ecosystem where AI agents can be built, deployed, and managed with unprecedented ease and efficiency. The platform’s capabilities are organized into four key pillars: Build, Scale, Govern, and Optimize, each addressed by a specific set of demos.
Building the Foundation: Crafting AI Agents with ADK
The initial set of demos focuses on the foundational aspects of AI agent development, all built upon the code-first ADK. These are designed to guide developers from the ground up, establishing a solid understanding of the core technologies and methodologies.
1. Your First Agent: An ADK On-Ramp
The journey begins with the "ADK Foundation codelab." This introductory session is crucial for newcomers, providing a step-by-step guide to setting up the development environment. Participants will learn to define a basic conversational agent powered by Gemini, configure its essential settings, and test its functionality through both command-line interfaces and web-based user interfaces. This codelab serves as the essential starting point for anyone new to the ADK.
2. Event-Driven Approval with Human-in-the-Loop
A more comprehensive demonstration of the Agent Platform in action is the "ambient expense agent codelab." This demo showcases the construction of a corporate expense approval agent. Leveraging ADK 2.0’s graph-based workflow API, expenses below a defined threshold are automatically approved. Transactions exceeding this threshold undergo a multi-stage review process. This includes a pre-LLM security screen for Personally Identifiable Information (PII) redaction and prompt-injection defense, followed by a Gemini compliance analysis. Finally, the process pauses for a human-in-the-loop review before finalization. The agent is integrated with FastAPI, triggered by Pub/Sub events, and evaluated using an LLM-as-judge approach. This agent serves as a recurring example throughout the Scale and Govern sections, highlighting its versatility.
3. Connecting Agents to Data: The Model Context Protocol (MCP)
Understanding how to integrate AI agents with existing data sources is paramount. The "MCP codelab" addresses this by demonstrating the creation of reusable MCP tools. These tools enable Gemini to query BigQuery, search files, and interact with APIs. The open nature of MCP ensures that tools built on this protocol are interoperable across various vendors and frameworks, promoting a more connected AI development landscape.
4. Dynamic User Interfaces with Agent-to-UI (A2UI)
Creating engaging user experiences often requires dynamic and responsive interfaces. The "A2UI codelab" illustrates how to develop an agent capable of rendering real interface components, such as layouts, charts, and interactive menus. These components update dynamically in real-time as the conversation progresses, effectively allowing the agent to assemble the necessary user interface on the fly. This capability is vital for applications requiring rich, interactive user engagement.
Scaling for Production: Robust Deployment and Orchestration
Once an AI agent is built, the next critical phase involves preparing it for production environments, which demands robust scaling, memory management, and orchestration capabilities.
5. Stateful Agents in Agent Runtime
The "Stateful Data Science Agent codelab" guides developers through deploying a BigQuery agent to Agent Runtime (formerly Agent Engine). This agent is designed to remember user preferences across sessions using Memory Bank. The demo highlights how Agent Runtime automatically handles the underlying infrastructure, scaling, and session management, allowing developers to focus on agent logic rather than infrastructure complexities.
6. Long-Running Agents: Pause, Resume, and Context Preservation
Enterprise workflows can often span extended periods, necessitating agents that can reliably pause, resume, and maintain context over days or weeks. A dedicated tutorial walks through building such agents, focusing on three key architectural patterns: durable state machines, event-driven idle time handling, and checkpoint-and-resume with persistent sessions. The example used is an onboarding coordinator agent that can survive container restarts and resume its task precisely where it left off, demonstrating resilience and continuity.
7. Production Deployment of the Expense Agent via Agents CLI
Building upon the earlier expense agent demo, the "Deploy to Agent Runtime codelab" demonstrates its progression to a production-ready state. Developers will learn to scaffold deployment configurations using the Agents CLI, previewing changes with a dry run before live deployment. This process automatically integrates essential services like Cloud Trace, Cloud Logging, and BigQuery Agent Analytics. Furthermore, the agent is automatically registered in Agent Registry, ensuring its discoverability across the organization immediately upon deployment.
8. Bridging Agents and Real-World Frontends
The "frontend codelab" brings together the various components of the agent development lifecycle. It details the creation of a manager dashboard deployed on Cloud Run. This dashboard connects to Agent Runtime via an OIDC-authenticated Pub/Sub pipeline, enabling managers to resume paused human-in-the-loop sessions directly from their browser. This demo effectively ties the expense agent and its deployment into a complete end-to-end enterprise architecture, showcasing a fully realized application.
Governing AI Agents: Ensuring Security and Compliance
Scaling AI agents across an organization necessitates robust governance mechanisms to manage access, track endpoints, and filter traffic, ensuring security and compliance.
9. Securing the Agent Lifecycle
The "Secure Agentic Coding codelab" focuses on embedding security from the initial stages of development. It demonstrates building a shopping assistant agent using test-driven development (TDD), integrating a custom STRIDE threat model, and setting up a Semgrep pre-commit hook. A PreToolUse gate is configured to block risky actions before execution. The demo illustrates this by intentionally introducing a hardcoded API key, which the agent detects and rectifies immediately upon hook activation, highlighting proactive security measures.
10. Access Control with Agent Gateway
Runtime governance is addressed in the "Agent Gateway codelab." This demo involves deploying a multi-tool ADK agent on Agent Runtime that communicates with MCP servers on Cloud Run via Agent Gateway. Each agent is assigned a unique identity with end-to-end mutual TLS (mTLS) encryption. All outbound calls are subjected to Identity-Aware Proxy (IAP) authentication and IAM authorization. Additionally, Model Armor inspects all content for potential prompt injection and data leakage, presenting a comprehensive, production-grade governance stack within a single demonstration.
Optimizing AI Agents: Continuous Improvement and Interoperability
Deploying an AI agent is merely the beginning; continuous optimization is key to maintaining and improving performance. Agent Platform provides tools to refine agents and ensure that changes do not inadvertently introduce new issues.
11. Driving Quality with the Agent Evaluation Flywheel
The "driving the agent quality flywheel" tutorial introduces a five-stage evaluation process that can be executed directly from a developer’s coding agent. This flywheel involves preparing data (from OpenTelemetry traces, hand-crafted examples, or synthesized scenarios), running inference, grading using Google’s adaptive AutoRaters, analyzing failure clusters, and executing targeted optimizations. The AutoRaters are built on principles used by Google to evaluate its own models and first-party agents, developed in partnership with DeepMind. Developers can describe desired measurements in natural language, and the coding agent manages the rest. This systematic approach ensures that prompt tweaks lead to verifiable improvements without regressions.
12. Cross-Language Pipelines with Agent-to-Agent (A2A)
In large enterprises, different teams often develop agents using disparate programming languages. The "build cross-language multi-agent team" tutorial addresses this challenge by showcasing a contract compliance pipeline. Here, a Python-based agent extracts terms using Gemini, while a Go-based agent validates them against corporate policy. These agents communicate via the Agent-to-Agent (A2A) protocol and are orchestrated by ADK. The demo illustrates how RemoteA2aAgent can transform any A2A-compliant service into a local sub-agent with minimal code, facilitating interoperability.
13. Orchestrating Across Frameworks: CrewAI, LangGraph, A2A, and ADK
Recognizing that production teams rarely standardize on a single agent framework, the "scale agents across frameworks" codelab demonstrates orchestration across multiple platforms. This includes an ADK control room delegating planning to a LangGraph state machine, which then dispatches tasks to a CrewAI execution crew. All these components are interconnected via the A2A protocol. This architecture allows for automatic replanning by the control room if any step in the pipeline fails, ensuring resilience and continuous operation.
Getting Started with the Gemini Enterprise Agent Platform
Google provides clear pathways for developers to engage with the Gemini Enterprise Agent Platform. For those seeking a quick overview of the entire agent development lifecycle, a comprehensive walkthrough video is available. Alternatively, developers can directly install the Agents CLI, integrate it with their preferred coding agent, and begin building immediately through the Google Cloud Console. This multi-pronged approach ensures that developers of all skill levels and preferences can readily access and leverage the platform’s advanced capabilities. The accessibility of these demos and tools signifies a major advancement in enabling enterprises to harness the full potential of AI agents for complex business challenges.
