On April 22, 2026, at Google Cloud Next in Las Vegas, Google did something that went beyond renaming a product. Vertex AI — the platform used by tens of thousands of developers to build and deploy LLM applications — became the Gemini Enterprise Agent Platform. And unlike most rebrands, this one came with real consequences: a migration deadline, a new SDK, and an architectural shift that puts agents at the center of everything Google Cloud does in AI.

If you're still using the Vertex AI SDK, the deprecated modules stop receiving updates after June 24, 2026. That's not a far-off concern. But before getting to migration, it's worth understanding what actually changed and why Google made this move.

Why Google Retired the Vertex AI Brand

Vertex AI started as a model-serving platform. You uploaded data, trained models, ran inference. That worked fine for ML teams building classifiers. It wasn't designed for what enterprises are actually building in 2026: multi-step agentic workflows that run for hours or days, orchestrate dozens of tools, and coordinate across teams of specialized agents.

The Gemini Enterprise Agent Platform is the answer to that gap. It's not a layer on top of Vertex AI — it's a reorganization of the entire developer surface around one question: how do you build, deploy, govern, and observe AI agents at enterprise scale?

All existing Vertex AI services continue to work. The team didn't break anything. But going forward, every new capability ships through the Agent Platform, not Vertex AI. The roadmap has moved.

The Platform Architecture: Eight Core Components

The Gemini Enterprise Agent Platform bundles what were previously scattered tools into a coherent stack. Here's what's new or meaningfully upgraded:

Agent Studio is a low-code visual canvas for designing agent reasoning loops and workflows. Developers build and prototype; business users can inspect agent logic without reading code. It replaces the older Agent Builder interface with a far richer design surface.

Agent Runtime handles deployment of long-running agents that maintain state for days at a time. This matters for anything beyond a single-turn interaction — think a sales prospecting sequence that runs overnight, or a compliance review agent that works through a queue of contracts over a week. Previous runtimes timed out too quickly to be useful here.

Agent Memory Bank provides persistent, long-term context that survives across sessions. Agents build Memory Profiles — structured summaries of high-accuracy details — that can be retrieved with low latency. The Memory Bank dynamically generates and curates these profiles from conversation history, so agents don't start cold every time they're invoked.

Agent Gateway acts as the network layer between agents, tools, and external services. It enforces security policies and Model Armor protections, and provides unified connectivity across any environment — cloud, hybrid, or on-premises. Think of it as the reverse proxy for your agent mesh.

Agent Identity gives every agent a unique cryptographic ID. Every action an agent takes is logged and mapped back to defined authorization policies. This matters for compliance: you can audit exactly which agent did what, when, and under whose authorization.

Agent Registry is the internal catalog for your agent ecosystem. Every internal agent, tool, and skill gets indexed here. When a new agent needs to delegate a task, it queries the Registry to discover what's available rather than relying on hardcoded references.

Agent Observability provides structured logging, distributed tracing, and performance metrics for the entire agent mesh — similar to what APM tools provide for microservices, but built for the agentic pattern.

Agent Simulation lets you test agents against synthetic environments before production. You can inject failure scenarios, simulate tool unavailability, or stress-test multi-agent coordination without touching live systems.

A2A Protocol: The Interoperability Layer

The Agent2Agent (A2A) protocol is what makes all of this composable across frameworks and vendors. Google originally developed A2A, then donated it to the Linux Foundation in early 2026. Version 1.2 shipped in March 2026, and as of April 2026, more than 150 organizations have it running in production.

The core idea is simple: A2A is to agents what HTTP is to web services. It defines a standard envelope for how one agent requests work from another — regardless of what framework either agent was built on. An agent built with LangGraph can delegate a subtask to an agent built with CrewAI. A proprietary enterprise agent can hand off to an open-source agent running on a different cloud. The framework choice doesn't matter because A2A abstracts the communication layer.

A2A complements MCP (Model Context Protocol), which handles tool connectivity. MCP connects agents to tools; A2A connects agents to agents.

The implication: if you're already using any of these frameworks, your agents are already capable of participating in an A2A network. You don't need to rewrite anything to connect them to agents on the Gemini Enterprise Agent Platform.

ADK v1.0: Build Agents in Any Language

The Agent Development Kit (ADK) hit stable v1.0 across all four supported languages in early 2026: Python, TypeScript, Go, and Java. Each language SDK has identical feature parity at the protocol level. This is significant for enterprise teams — a Java shop doesn't need to maintain a Python service just to build agents.

The Python ADK remains the most mature, with the largest set of examples and the active community from the original open-source release. But the Go and Java SDKs are production-ready, and Google has committed to maintaining them.

For teams already using the Google ADK for Python, upgrading to ADK v1.0 is largely a pip upgrade — the v1.0 release focused on stability and production guarantees, not a complete API redesign. ADK Python 2.0 (beta) adds Workflows and Agent Teams, but v1.0 is the stable target for production use.

A Minimal A2A Agent in Python

Here's a minimal ADK agent that exposes itself via A2A:

from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.tools import ToolContext

# Define a simple tool
def lookup_order_status(order_id: str, tool_context: ToolContext) -> dict:
    """Look up the status of an order by ID."""
    # Real implementation would query a database
    return {"order_id": order_id, "status": "shipped", "eta": "2026-04-28"}

# Create the agent
agent = Agent(
    name="order-status-agent",
    model="gemini-3.1-flash",
    description="Looks up order status for customer service queries",
    tools=[lookup_order_status],
)

# Run with A2A server enabled
runner = Runner(
    agent=agent,
    app_name="order-service",
    session_service=InMemorySessionService(),
)

# This starts an HTTP server on port 8080 with A2A protocol endpoints
runner.serve(host="0.0.0.0", port=8080, enable_a2a=True)

With enable_a2a=True, this agent is immediately discoverable by other A2A-compliant agents. Any LangGraph, CrewAI, or AutoGen agent that knows this agent's endpoint can delegate order status lookups to it without any additional glue code.

To deploy this to the Gemini Enterprise Agent Platform's Agent Runtime:

gcloud agent-platform agents deploy order-status-agent \
  --source . \
  --region us-central1 \
  --runtime-type long-running \
  --a2a-enabled

The --runtime-type long-running flag enables the multi-day runtime with persistent state. The --a2a-enabled flag registers the agent in your Agent Registry and exposes A2A endpoints automatically.

Migrating from Vertex AI

The migration path from Vertex AI SDK to the Google Gen AI SDK is straightforward in most cases. The APIs are similar by design, and Google has published language-specific migration guides for Python, Java, JavaScript, and Go.

The critical deadline: the deprecated Vertex AI SDK modules stop receiving updates on June 24, 2026. This doesn't mean your existing code breaks immediately, but you'll be running on an unpatched SDK in an area that's actively evolving.

Python migration — the most common case:

# Before (Vertex AI SDK)
import vertexai
from vertexai.generative_models import GenerativeModel

vertexai.init(project="my-project", location="us-central1")
model = GenerativeModel("gemini-3.1-pro")
response = model.generate_content("Explain what changed in Google Cloud Next 2026")

# After (Google Gen AI SDK)
from google import genai

client = genai.Client(project="my-project", location="us-central1")
response = client.models.generate_content(
    model="gemini-3.1-pro",
    contents="Explain what changed in Google Cloud Next 2026"
)

The functional difference is minimal. The new client is stateless, which makes it easier to use in serverless environments. Authentication still uses Application Default Credentials (ADC).

For teams with larger migrations, Google's official migration guide at docs.cloud.google.com/gemini-enterprise-agent-platform/models/deprecations/genai-vertexai-sdk includes automated codemods that handle the rename-level changes. The manual work is mainly in updating how you handle streaming responses and how you configure safety settings, where the new SDK has a slightly different interface.

Teams using the Gemini 3.1 Pro API directly through Vertex AI should prioritize this migration — the new endpoint structure includes access to the full 200+ model catalog in Model Garden, including third-party models like Claude Opus and Haiku, which weren't available through the old Vertex AI model selection.

Common Mistakes When Adopting the Agent Platform

Treating Agent Runtime like a serverless function. The long-running runtime is designed for stateful, persistent agents. If your agent is stateless and runs in under 60 seconds, deploying it to Agent Runtime adds overhead without benefit. Use Cloud Run or Cloud Functions for short-lived, stateless agents. Agent Runtime is for the 10% of workflows that need persistent state.

Skipping Agent Identity for internal agents. It's tempting to skip the cryptographic identity setup for agents that "only talk to internal systems." But Agent Identity is how Agent Gateway enforces authorization policies. Without it, your internal agents bypass the governance layer — which matters the moment you need to audit what an agent did.

Conflating A2A and MCP. A2A handles agent-to-agent delegation. MCP handles agent-to-tool connections. An agent that queries a database uses MCP. An agent that hands off a subtask to a specialized agent uses A2A. You'll likely need both in a real system. If you're building from scratch, reach for MCP for tool connections and A2A for agent delegation.

Blocking on Agent Memory Bank latency. The Memory Bank is optimized for retrieval accuracy, not for sub-10ms reads. It's appropriate for warm context that gets loaded at the start of a session — not for hot-path lookups inside a single response generation. Use it to prime the agent, not to replace a cache.

Not deploying to Agent Registry. The Registry is optional in development but expected in production. If your agents aren't registered, they can't be discovered by other agents in the mesh. This is the difference between an isolated agent and a composable service.

FAQ

Q: Is Vertex AI being shut down?

No. All existing Vertex AI services continue to work. The rebrand means that new capabilities ship exclusively through the Gemini Enterprise Agent Platform, not as Vertex AI updates. Google has stated that all Vertex AI services and roadmap evolutions will be delivered through the Agent Platform going forward. The immediate action item is migrating from the deprecated SDK modules before June 24, 2026.

Q: Do I need to use ADK to build on the Gemini Enterprise Agent Platform?

No. ADK is Google's first-party toolkit and the fastest path to integration, but the platform is framework-agnostic. If you're using LangGraph or CrewAI, both have native A2A support and official connectors for the Agent Platform. The platform's Agent Gateway accepts any A2A-compliant request regardless of the originating framework.

Q: What's the difference between Agent Memory Bank and a vector database?

Agent Memory Bank is an abstraction, not a replacement. Under the hood, it uses Google Cloud's infrastructure, but the interface is higher-level: you don't write embeddings or queries. The Memory Bank builds Memory Profiles automatically from agent sessions and handles retrieval. For custom RAG pipelines or structured knowledge bases, you'd still use a vector database like Pinecone or Qdrant directly. Memory Bank covers the conversational context layer; a vector database covers the knowledge retrieval layer.

Q: When should I use A2A versus just calling another agent's API directly?

Use A2A when you want the call to flow through Agent Gateway's security and observability layer — which means it gets logged, rate-limited, and policy-checked. Use direct API calls when you're prototyping or when the inter-agent call is internal to a single deployment context. In production, almost everything should go through A2A so Agent Identity and Agent Observability have full visibility into what's happening across your agent mesh.

Key Takeaways

• The Gemini Enterprise Agent Platform is Vertex AI's replacement as Google Cloud's primary AI development surface. The brand change reflects a genuine architectural shift — the entire roadmap now centers on agents, not models.
• Migration deadline: Vertex AI SDK deprecated modules stop receiving updates on June 24, 2026. Run the genai-vertexai-sdk migration guide now, not later.
• ADK v1.0 is stable in Python, TypeScript, Go, and Java. All four are production-ready. The Python SDK has the most community content; Go and Java are strong options for teams with existing language constraints.
• A2A v1.2 (Linux Foundation) provides the interoperability layer. With native A2A support in LangGraph, CrewAI, LlamaIndex, Semantic Kernel, and AutoGen, you can build cross-framework multi-agent systems without custom glue code.
• Agent Memory Bank, Agent Identity, and Agent Registry are the components that separate a "demo agent" from production-grade enterprise deployment. Build with all three from the start.

Bottom Line

If you're building agents on Google Cloud, the Gemini Enterprise Agent Platform is not optional — it's where all future investment is going. The A2A protocol and ADK v1.0 multi-language support make this the most complete enterprise agent stack Google has shipped. Start the Vertex AI SDK migration now, adopt Agent Identity from day one, and use A2A for any inter-agent communication you plan to govern or audit.