Building AI agents with Claude in Google Cloud's Vertex AI | Code w/ Claude

Ivan Nardini from Google Cloud demonstrates how to build, enhance, and productionalize AI agents using Google Cloud's agent stack. The session covers the challenges of deploying agents and introduces the Agent Development Kit (ADK) for building, the Vertex AI Agent Engine for managed deployment, and protocols like MCP and Agent-to-Agent for tool integration and inter-agent communication, using Claude on Vertex AI as the core LLM.

July 31, 2025 4 min read

Building AI agents with Claude in Google Cloud's Vertex AI | Code w/ Claude — source: https://www.youtube.com/watch?v=TUysIAtxyrQ

Ivan Nardini, a Developer Relations Engineer at Google Cloud, outlines the significant challenges developers face when moving AI agents from prototype to production. The core difficulties are threefold:

Fragmented Landscape: The multitude of frameworks and tools for agent development requires complex integration efforts.
Interoperability: Enabling communication between agents built with different frameworks is not a straightforward task.
Operational Overhead: Managing agents in production involves significant work in monitoring, logging, and governance, which is difficult to scale.

To address these issues, Google Cloud has developed a comprehensive agent stack designed to standardize and streamline the entire lifecycle of AI agent development and deployment.

The Google Cloud Agent Stack

The proposed stack consists of four main components that create a cohesive ecosystem for building and managing sophisticated agentic systems:

Agent Development Kit (ADK): An open-source, code-first framework for efficiently building, evaluating, and deploying agents. It is designed to be developer-friendly and align with software engineering best practices.
Model-Centric Protocol (MCP): ADK is compatible with MCP, a standard that allows agents to seamlessly consume tools and context. This enables integration with any existing MCP-compatible server, standardizing how agents access external capabilities.
Vertex AI Agent Engine: A managed platform designed specifically to deploy, manage, and scale AI agents in production. It handles the operational complexities, including infrastructure, monitoring, logging, and observability, allowing developers to focus on agent logic.
Agent-to-Agent Protocol: An open protocol that facilitates seamless communication and collaboration between agents, even if they are built using different frameworks (e.g., ADK, LangChain, CrewAI). It is built on standard technologies like HTTP and JSON-RPC and is designed to be enterprise-ready.

Building an Agent with ADK and Claude on Vertex AI

The presentation demonstrates a practical workflow for building a multi-agent system.

Accessing Claude on Vertex AI

Claude models, including the latest versions, are accessible through the Vertex AI Model Garden. This centralized hub allows developers to discover, test (via the Vertex AI Studio prompt UI), and integrate models like Claude 3.5 Sonnet into their applications using an API.

Step 1: Creating a Simple Agent

A basic “Birthday Planner” agent is created using ADK. The process is simplified to require just three files: agent.py for the logic, an environment file, and an __init__.py file.

The core ADK concepts include:

LLMAgent: The brain of the agent, which requires a model (like Claude), a name, instructions, and tools.
Tools: Skills that can be assigned to an agent. ADK provides pre-built tools and allows for custom tool creation.
Runner: A component that executes the agent, manages the conversation state (session), and integrates with a command-line interface (adk run) and a web UI (adk web) for interaction and debugging.
Session: Stores the conversation history, enabling stateful interactions.

Step 2: Enhancing with Multiple Agents and MCP

The simple agent is extended into a multi-agent system.

A Calendar Service Agent is introduced to schedule events. This agent integrates an existing MCP server as a tool with just two lines of code, demonstrating ADK’s power to leverage standardized external tools without reinvention.
An Orchestrator Agent is created to route user requests to the appropriate agent (either the Birthday Planner or the Calendar Agent). This is achieved by passing the individual agents as “tools” to the orchestrator, which then determines the correct one to use based on the user’s prompt.
The adk web command launches a user-friendly UI for debugging the more complex multi-agent system, providing visibility into which agent is handling a given task.

Step 3: Deployment with Vertex AI Agent Engine

The final step is deploying the agent to a scalable, managed environment. Instead of manually containerizing the agent, setting up infrastructure, and implementing monitoring, the Vertex AI Agent Engine automates this process.

By running a simple deployment script, the developer can push their agent to the Agent Engine. This provides:

A managed, scalable runtime environment.
Automatic observability, including monitoring for queries, latency, CPU, and memory usage.
Centralized logging and session management.
Integration with evaluation services to continuously improve the agent over time.

Fostering Collaboration with the Agent-to-Agent Protocol

For scenarios where agents are built with different frameworks, the Agent-to-Agent Protocol provides a common language for interaction. It relies on two key concepts:

Agent Skills: Describes the specific functions and capabilities an agent possesses.
Agent Card: A digital business card that allows other agents and applications to discover an agent’s skills and learn how to interact with it.

This protocol enables the creation of complex, heterogeneous systems where specialized agents, regardless of their underlying framework, can collaborate to achieve complex tasks.