Vertex AI is now Agent Platform. Agent Designer is now Agent Studio. What stayed the same — and what it means for enterprise teams building production agents today.

Contents

The Platform That Keeps Evolving — And Why That’s a Good Thing
Part 1: The Platform Mental Model — Five Layers
Part 2: Agent Studio — The No-Code/Low-Code Canvas

What Agent Studio Actually Is
Your First Agent in Agent Studio — Step by Step

Part 3: Agent Garden — Blueprints That Actually Work
Part 4: RAG Engine — Grounding Agents on Enterprise Data

Step 1: Create a RAG Corpus
Step 2: Import Documents
Step 3: Query with Gemini + RAG Tool
Step 4: RAG-Grounded ADK Agent

Part 5: Agent Search — Out-of-the-Box Search for Specialised Domains
Part 6: Memory Bank — Long-Term Personalisation Across Sessions
Part 7: Deploying to Agent Runtime
Part 8: Built-in Evaluation — Quality Before You Ship
Part 9: Governance — Policies, IAM, and Agent Gateway
The Complete Platform Map
Where to Start
Resources

The Platform That Keeps Evolving — And Why That’s a Good Thing

If you’ve been tracking Google’s AI platform story, you’ve watched a rapid-fire succession of rebrands: Dialogflow → Agent Builder → Vertex AI → now Gemini Enterprise Agent Platform. At Google Cloud Next 2026, Google announced the consolidation of everything — Vertex AI, Agentspace, Model Garden, ADK, and the Agent Runtime — into a single unified platform. The low-code builder that was called Agent Designer since December 2024 became Agent Studio, now generally available.

This guide cuts through the naming history and focuses on what you can actually build today: production-grade agents using the full platform stack — Agent Studio for no-code/low-code design, RAG Engine for grounding on enterprise data, Memory Bank for long-term personalisation, Agent Runtime for deployment, and built-in evaluation for quality assurance.

Whether you’re a developer who wants code, a builder who wants clicks, or an architect who needs to understand the full system — this guide covers all three.

Part 1: The Platform Mental Model — Five Layers

Before touching the console or writing a line of code, understand how the five layers of the Gemini Enterprise Agent Platform fit together.

Gemini Enterprise Agent Platform is a unified platform to build, deploy, govern, and optimize enterprise-grade AI agents and model-based solutions. It supports the complete AI lifecycle — from accessing over 200 foundation models to deploying and managing your agents.

Here’s how the five layers stack:

┌──────────────────────────────────────────────────────────────────┐
│  LAYER 1 — AGENT STUDIO (no-code / low-code visual canvas)        │
│  Design agents, test prompts, build reasoning flows visually      │
├──────────────────────────────────────────────────────────────────┤
│  LAYER 2 — ADK (code-first agent framework)                       │
│  LlmAgent, SequentialAgent, ParallelAgent, LoopAgent, AgentTool  │
├──────────────────────────────────────────────────────────────────┤
│  LAYER 3 — KNOWLEDGE LAYER                                        │
│  RAG Engine · Agent Search · Vector Search · Memory Bank         │
├──────────────────────────────────────────────────────────────────┤
│  LAYER 4 — AGENT RUNTIME (managed deployment + scaling)           │
│  Agent Engine (Vertex AI) · Cloud Run · GKE                      │
├──────────────────────────────────────────────────────────────────┤
│  LAYER 5 — GOVERNANCE                                             │
│  Agent Identity · IAM · Agent Gateway · Business Policies        │
└──────────────────────────────────────────────────────────────────┘

Agent Platform meets you where you are, with tools for all skill levels: Agent Studio to design agents and interact with models without code; Colab Enterprise Notebooks for code-based development and experimentation; Agent Development Kit to build sophisticated agents capable of complex reasoning and tool use with a modular, model-agnostic framework.

The platform’s philosophy: start in Agent Studio, graduate to ADK code when you need more control, deploy both the same way via Agent Runtime.

Part 2: Agent Studio — The No-Code/Low-Code Canvas

Agent Studio is where most teams start. It’s a visual canvas inside the Google Cloud console for designing, prototyping, and managing agent reasoning loops and workflows — no Python required to get something running.

What Agent Studio Actually Is

Agent Studio, Google’s new low-code interface for building, testing, and publishing natural-language agents, is generally available. The product was in preview as Agent Designer since December 2024. What may be more interesting here is what developers can now actually build with it.

In the console, Agent Studio gives you:

Visual reasoning loop designer — drag connections between the model, tools, and data sources. Define the agent’s instruction (system prompt) in a structured editor with variable interpolation support.

Live test panel — chat with your agent directly in the console. Every tool call, retrieval step, and model response is visible in the trace panel alongside the conversation.

Tool connection UI — connect Google Search grounding, Agent Search corpora, Cloud Functions, OpenAPI specs, or MCP servers as tools — all without writing integration code.

Agent Garden integration — one-click import of prebuilt templates for common use cases: customer support, document Q&A, IT helpdesk, HR FAQ, code assistant.

Your First Agent in Agent Studio — Step by Step

Step 1: Open the console. Navigate to console.cloud.google.com, select your project, and search for “Agent Studio” in the top search bar. Or navigate directly: Agent Platform → Studio → Create Agent.

Step 2: Configure the agent basics. Give the agent a name (e.g. policy-assistant), select a model (gemini-2.0-flash for speed, gemini-2.5-pro for complex reasoning), and write the instruction. Be specific:

You are an enterprise policy assistant for Acme Corp.
Your job is to answer employee questions about company policies accurately.
Always retrieve from the knowledge_base tool before answering.
Cite the document name and section in every response.
If the policy is not found, say so -- do not invent details.

Step 3: Add a tool. Click Add Tool → Agent Search → select your knowledge corpus (or create one). Agent Search becomes the knowledge_base tool the instruction references.

Step 4: Test in the live panel. Type a query: “What is the parental leave policy?” Watch the trace: model receives query → calls knowledge_base → retrieves 3 passages → generates grounded response with citation.

Step 5: Export to ADK. When ready for code-first control, click Export → ADK Python. Agent Studio generates the full LlmAgent definition as a Python file — ready to extend, version, and deploy via CI/CD.

Part 3: Agent Garden — Blueprints That Actually Work

Rather than starting from a blank canvas, Agent Garden gives you production-tested templates for the most common agent patterns.

Agent Garden is a library of prebuilt agents and templates to accelerate development.

The adk-samples repository hosts the open-source versions of these templates. Each one is a complete, runnable ADK project with tools, instructions, evaluation datasets, and deployment configs. Current highlights:

Template	Use case
`customer-service`	Multi-turn support agent with escalation and order lookup
`document-qa`	RAG-backed Q&A over uploaded documents
`code-assistant`	Code generation, review, and explanation
`data-analyst`	Natural language to BigQuery SQL
`travel-concierge`	Multi-agent travel planning (flight + hotel + activities)
`folio-advisor`	Financial portfolio analysis with tool use

To use a template from the CLI:

# Install the Google ADK
pip install google-adk

# Clone the adk-samples repository
git clone https://github.com/google/adk-samples.git
cd adk-samples/python/agents/customer-service

# Run locally
adk run agent.py

# Inspect in the dev UI
adk web

Each sample is a working starting point, not a toy. The customer-service template handles order lookups, refund requests, escalation to human agents, and session memory — all wired and ready to customise.

Part 4: RAG Engine — Grounding Agents on Enterprise Data

The most powerful capability in the platform for enterprise deployments is RAG Engine: a fully managed data framework for connecting private enterprise data to LLM agents.

RAG Engine on Gemini Enterprise Agent Platform is a data framework for building context-augmented LLM applications. Context augmentation occurs when you apply an LLM to your data. This implements retrieval-augmented generation (RAG).

RAG Engine handles the full pipeline: document ingestion, parsing, chunking, embedding, vector indexing, and retrieval — all managed, serverless, and integrated with the Gemini models.

Step 1: Create a RAG Corpus

A corpus is the container for your indexed documents. Create it once; it persists and auto-updates when you add new files.

# rag_setup.py
# pip install google-cloud-aiplatform

import vertexai
from vertexai.preview import rag

PROJECT_ID = "your-gcp-project-id"
LOCATION = "us-central1"

vertexai.init(project=PROJECT_ID, location=LOCATION)

# Create the corpus
corpus = rag.create_corpus(
    display_name="enterprise-knowledge-base",
    description="Internal policy docs, product manuals, and SOPs",
)
print(f"Corpus created: {corpus.name}")

Step 2: Import Documents

RAG Engine supports Google Cloud Storage, Google Drive, Google Docs, inline text, and Slack/Confluence via connectors. It automatically parses PDFs, Word docs, HTML, and plain text.

# rag_import.py
import vertexai
from vertexai.preview import rag

PROJECT_ID  = "your-gcp-project-id"
LOCATION    = "us-central1"
CORPUS_NAME = "projects/your-gcp-project-id/locations/us-central1/ragCorpora/YOUR_CORPUS_ID"

vertexai.init(project=PROJECT_ID, location=LOCATION)

# Import files from Google Cloud Storage
response = rag.import_files(
    corpus_name=CORPUS_NAME,
    paths=[
        "gs://your-bucket/docs/policy_manual_2025.pdf",
        "gs://your-bucket/docs/product_catalogue.pdf",
    ],
    transformation_config=rag.TransformationConfig(
        chunking_config=rag.ChunkingConfig(
            chunk_size=512,     # tokens per chunk
            chunk_overlap=100,  # overlap for context continuity
        ),
    ),
)
print(f"Files imported: {response.imported_rag_files_count}")

Step 3: Query with Gemini + RAG Tool

Attach the corpus as a retrieval tool and pass it to a Gemini model. Every generate_content call now retrieves before generating.

# rag_query.py
import vertexai
from vertexai.preview import rag
from vertexai.generative_models import GenerativeModel, Tool

PROJECT_ID  = "your-gcp-project-id"
LOCATION    = "us-central1"
CORPUS_NAME = "projects/your-gcp-project-id/locations/us-central1/ragCorpora/YOUR_CORPUS_ID"

vertexai.init(project=PROJECT_ID, location=LOCATION)

# Build the RAG retrieval tool
rag_retrieval_tool = Tool.from_retrieval(
    retrieval=rag.Retrieval(
        source=rag.VertexRagStore(
            rag_corpora=[CORPUS_NAME],
            similarity_top_k=5,           # return top 5 passages
            vector_distance_threshold=0.5, # filter below this similarity score
        ),
    )
)

# Attach to Gemini -- now every response is grounded in your documents
model = GenerativeModel(
    model_name="gemini-2.0-flash",
    tools=[rag_retrieval_tool],
)

response = model.generate_content(
    "What is our refund policy for enterprise software licences?"
)
print(response.text)

Step 4: RAG-Grounded ADK Agent

For multi-agent systems, wrap the RAG corpus as an ADK tool and give it to a specialist agent:

# rag_agent.py
import vertexai
from google.adk.agents import LlmAgent
from google.adk.tools import VertexAiRagRetrieval

PROJECT_ID  = "your-gcp-project-id"
LOCATION    = "us-central1"
CORPUS_NAME = "projects/your-gcp-project-id/locations/us-central1/ragCorpora/YOUR_CORPUS_ID"

vertexai.init(project=PROJECT_ID, location=LOCATION)

# Wrap the RAG corpus as an ADK retrieval tool
rag_tool = VertexAiRagRetrieval(
    name="knowledge_base",
    description="Searches internal documents: policies, SOPs, product specs.",
    rag_corpora=[CORPUS_NAME],
    similarity_top_k=5,
)

# Policy agent grounded in enterprise docs
policy_agent = LlmAgent(
    model="gemini-2.0-flash",
    name="policy_agent",
    description="Answers questions about company policies and SOPs using the knowledge base.",
    instruction=(
        "You are an enterprise policy assistant. "
        "Always use the knowledge_base tool to retrieve relevant policies before answering. "
        "Cite the source document and page number in your response. "
        "Never make up policy details -- only reference retrieved content."
    ),
    tools=[rag_tool],
)

Reference: RAG Engine overview

Part 5: Agent Search — Out-of-the-Box Search for Specialised Domains

RAG Engine handles unstructured documents. Agent Search handles specialised retrieval needs at enterprise scale — with pre-tuned modes for different industry domains.

Agent Search functions as an out-of-the-box RAG system for information retrieval, and has a specialised offering tuned for unique industry requirements. The four modes map to distinct use cases:

Custom Search (General) builds tailored search, personalisation, and generative experiences on your sites, content, catalogues, and blended data. Data sources: structured catalogues (hotels, directories), unstructured files with metadata, Google Workspace connectors, and public sites. This is the go-to for internal knowledge base search where your data lives in Drive, Confluence, or GCS buckets.

Site Search with AI Mode builds generative search with AI mode in a day using site content. It leverages Google’s index for real-time crawling and adds search summarisation on top. The distinct advantage: you get Google’s crawling infrastructure without running your own spider. Ideal for documentation sites and product help centres that change frequently.

Media Search is designed for media libraries — images, videos, and audio files. This is purpose-built for broadcast, publishing, and creative industries where the asset itself (not just its metadata) needs to be searchable.

AI Commerce Search handles retail catalogues specifically. If you’re building search for an e-commerce platform, this mode is tuned for product discovery, faceted filtering, and purchase intent signals.

Create an Agent Search app from the console at Agent Platform → Agent Search → Create App, or via the Discoveryengine API:

# Create a search app via the CLI
gcloud alpha discovery-engine engines create \
  --project=YOUR_PROJECT_ID \
  --location=global \
  --display-name="internal-knowledge-search" \
  --solution-type=SOLUTION_TYPE_SEARCH \
  --data-store-ids=YOUR_DATA_STORE_ID

Part 6: Memory Bank — Long-Term Personalisation Across Sessions

RAG Engine grounds agents in documents. Memory Bank grounds agents in users — storing personalised facts, preferences, and context that persist across every session, indefinitely.

Memory Bank stores long-term memory containing personalised information to enable more context-aware agent interactions across multiple sessions. From the console you can view, search, and manage the agent’s saved memories — including total memory count, token usage, and mutation rates.

In code, attach Memory Bank to any ADK agent:

# memory_agent.py
from google.adk.agents import LlmAgent
from google.adk.memory import VertexAiMemoryBankService

# Memory Bank service -- backed by Vertex AI managed storage
memory_service = VertexAiMemoryBankService(
    project="your-gcp-project-id",
    location="us-central1",
)

# Agent with persistent memory across all user sessions
personalised_agent = LlmAgent(
    model="gemini-2.0-flash",
    name="personalised_support_agent",
    description="Customer support agent with long-term memory of user preferences.",
    instruction=(
        "You are a helpful customer support agent. "
        "Remember the user's preferences, past issues, and account context. "
        "Use your memory to personalise every interaction. "
        "Always retrieve relevant memories before responding."
    ),
    memory_service=memory_service,
)

When a user says “I prefer email notifications, not SMS” in session 1, the agent writes that preference to Memory Bank. In session 47, three months later, the agent still knows it — without the user repeating themselves.

Note: As of January 2026, stored session events and memories are billed at $0.25 per 1,000 events or memories. Plan your retention policies accordingly.

Part 7: Deploying to Agent Runtime

Once your agent is built and tested, deploy it to Agent Runtime — the managed execution environment that handles auto-scaling, IAM, observability, and CI/CD integration.

The platform supports five deployment methods — choose based on your workflow:

Method	Best for
From agent object	Interactive Colab development, rapid prototyping
From source files	CI/CD pipelines, Terraform / Infrastructure as Code
From Dockerfile	Custom API server, specific runtime dependencies
From container image	Full build process control, lower deployment latency
From Developer Connect	Git-connected repos, native version control and collaboration

The simplest path — deploying directly from an in-memory agent object — takes three lines after your agent is defined:

# deploy_agent.py
import vertexai
from google.adk.agents import LlmAgent

PROJECT_ID = "your-gcp-project-id"
LOCATION   = "us-central1"

vertexai.init(project=PROJECT_ID, location=LOCATION)

def get_order_status(order_id: str) -> dict:
    """Look up the current status of an order by its ID."""
    return {"order_id": order_id, "status": "shipped", "eta": "2025-07-15"}

support_agent = LlmAgent(
    model="gemini-2.0-flash",
    name="support_agent",
    description="Handles customer order enquiries.",
    instruction="Help customers track their orders. Always use get_order_status.",
    tools=[get_order_status],
)

# Deploy to Agent Runtime -- three lines
from vertexai.preview.reasoning_engines import AdkApp

adk_app = AdkApp(agent=support_agent, enable_tracing=True)

remote_app = vertexai.preview.reasoning_engines.ReasoningEngine.create(
    adk_app,
    requirements=["google-adk>=1.0.0"],
    display_name="support-agent-v1",
    description="Customer support agent - order tracking",
)
print(f"Deployed: {remote_app.resource_name}")

After deployment, the agent is available as a REST endpoint, callable from any service with the right IAM permissions.

Reference: Deploy an agent on Agent Runtime

Part 8: Built-in Evaluation — Quality Before You Ship

Every agent needs evaluation before it reaches production. The Gemini Enterprise Agent Platform’s evaluation layer runs directly in the console (Evaluation tab) or via the Vertex AI SDK.

Three evaluation modes are available: Experiments for one-off quality assessments against a dataset, Metrics for defining and tracking custom quality dimensions, and Online Monitors for continuous evaluation in production.

Here’s a complete evaluation run using the SDK with a custom LLM-as-judge metric:

# evaluate_agent.py
import vertexai
from vertexai.preview.evaluation import EvalTask
from vertexai.preview.evaluation.metrics import (
    PointwiseMetric,
    PointwiseMetricPromptTemplate,
)

PROJECT_ID = "your-gcp-project-id"
LOCATION   = "us-central1"

vertexai.init(project=PROJECT_ID, location=LOCATION)

# Define a custom coherence metric using LLM-as-judge
coherence_metric = PointwiseMetric(
    metric="coherence",
    metric_prompt_template=PointwiseMetricPromptTemplate(
        criteria={
            "coherence": (
                "The response is logically structured, easy to follow, "
                "and the ideas connect naturally."
            )
        },
        rating_rubric={
            "5": "Perfectly coherent -- flows naturally, no gaps.",
            "3": "Mostly coherent with minor issues.",
            "1": "Incoherent -- hard to follow.",
        },
    ),
)

# Evaluation dataset (inputs + expected outputs)
eval_dataset = [
    {
        "prompt": "What is the refund policy for digital products?",
        "response": "Digital products are non-refundable unless the file is corrupted on delivery.",
        "reference": "Digital purchases are non-refundable except in cases of delivery errors.",
    },
    {
        "prompt": "How do I reset my password?",
        "response": "Go to the login page and click Forgot Password to receive a reset link by email.",
        "reference": "Click Forgot Password on the login page; a reset link will be emailed to you.",
    },
]

# Run the evaluation experiment
eval_task = EvalTask(
    dataset=eval_dataset,
    metrics=["exact_match", "rouge_l_sum", coherence_metric],
    experiment="support-agent-eval-v1",
)

eval_result = eval_task.evaluate()
print(eval_result.summary_metrics)

This experiment appears in the Agent Platform console under Evaluation → Experiments, where you can compare multiple runs side by side — exactly like the LangSmith experiment comparison we covered in the evaluation pillar post.

Reference: Evaluation on Agent Platform

Part 9: Governance — Policies, IAM, and Agent Gateway

Enterprise deployment isn’t complete without governance. The platform provides three governance layers.

Agent Identity gives each deployed agent its own service account identity — enabling fine-grained IAM permissions per agent. Your support agent can read from Firestore and call the orders API. It cannot write to BigQuery or access the HR database. Least privilege, enforced at the identity level.

Agent Gateway acts as the secure API layer between agents and the tools, MCP servers, and endpoints they call. It enforces IAM allow policies through Identity-Aware Proxy (IAP), controlling which agent identities can access which resources. Think of it as an API gateway that speaks agent — it understands tool calls, not just HTTP requests.

Business Policies (in the console at Policies → Business Policies) let you define natural-language rules that constrain agent behaviour across your organisation: “Agents must always disclose when they are AI.” “Agents must not discuss competitor pricing.” These are enforced at the Gateway layer, not in the individual agent instructions.

The Complete Platform Map

CONSOLE ENTRY POINTS
├── Agent Studio        → Visual agent designer, test, export to ADK
├── Agent Garden        → Prebuilt templates (customer-service, doc-QA, etc.)
├── RAG Engine          → Managed document indexing + retrieval
├── Agent Search        → Domain-specific search (general, site, media, commerce)
├── Memory Bank         → Long-term user personalisation
├── Agent Runtime       → Deploy, scale, monitor deployed agents
├── Evaluation          → Experiments, metrics, online monitors
└── Policies            → IAM, Agent Gateway, Business Policies

DEVELOPER ENTRY POINTS
├── ADK                 → Python/TypeScript/Go/Java agent framework
├── Colab Enterprise    → Notebooks with Vertex AI integration
├── Agents CLI          → adk run, adk web, adk eval, adk deploy
└── Developer Connect   → Git-linked CI/CD deployments

Where to Start

The right entry point depends on your team:

Non-technical teams building internal tools → start in Agent Studio, connect Agent Search to Google Drive, deploy to Agent Runtime with one click.

Developers building production agents → scaffold from Agent Garden, extend with ADK code, ground with RAG Engine, deploy from source files via the Agents CLI.

Enterprise architects designing multi-agent systems → use ADK for the agent layer, RAG Engine for knowledge, Memory Bank for personalisation, Agent Gateway for governance, and Agent Runtime for deployment across regions.

All three paths deploy to the same runtime, share the same evaluation tooling, and operate under the same governance layer. That’s the point of a unified platform.

Resources

Gemini Enterprise Agent Platform overview — official home
Agent Studio — Design agents — console visual designer
Agent Garden — prebuilt templates
ADK on Agent Platform — code-first development
RAG Engine overview — managed retrieval framework
RAG Engine quickstart — build your first corpus
Deploy an agent on Agent Runtime — all five deployment methods
Evaluation on Agent Platform — experiments, metrics, online monitors
Agent Governance overview — IAM, Gateway, Business Policies
adk-samples on GitHub — Agent Garden source templates
Google Cloud Next 2026 Agent Platform announcement — the rebrand explained

All code examples syntax-verified against Python 3.11. Install: pip install google-adk google-cloud-aiplatform. Free tier available: up to 10 agent engines, 90 days via Vertex AI Express Mode.

Must Read

How to Build an Agentic Workflow with n8n and an LLM (2026 Tutorial)