Google Cloud has folded Vertex AI into something broader. The new Gemini Enterprise Agent Platform is positioned as the single foundation for organisations that want to move past isolated AI experiments and run fleets of agents in production. It keeps the model building and selection capabilities developers already know, and adds the missing layers that enterprises kept asking for: identity, orchestration, long term memory, observability and security that actually scales.

If you have been trying to push agents beyond a flashy demo, this is the stack Google wants you to use. Below is a detailed walkthrough of what the platform actually does, how the pieces connect, and why it matters when agents start acting autonomously across your business.

From Vertex AI to an agent first platform

Vertex AI solved a real problem a few years ago. Building generative AI tools that were safe, grounded and reliable used to take enormous engineering effort. That baseline is now assumed. The harder challenge today is not training a model, it is running dozens or hundreds of agents that interact with each other, with enterprise systems, and sometimes with customers, without creating security blind spots.

Gemini Enterprise Agent Platform answers that by consolidating the full lifecycle into one product. Going forward, all Vertex AI services and roadmap updates are delivered exclusively through Agent Platform. It is not an add on, it is the successor. Technical teams get a single destination to design agents, ship them, and push them into the Gemini Enterprise app where employees can use them, all while IT keeps control of governance and access.

Through Model Garden, the platform offers first class access to more than 200 models. That includes Google’s own Gemini 3.1 Pro, Gemini 3.1 Flash Image, Lyria 3, open models like Gemma 4, and third party options such as Anthropic’s Claude Opus, Sonnet and Haiku. The point is flexibility. Pick the right model for the job rather than being locked in.

Four pillars, build, scale, govern, optimize

The platform is organised around four stages of an agent’s life. Understanding these pillars is the fastest way to see where each tool fits.

Build, from low code canvases to deep code

Two main entry points cover different developer profiles. Agent Studio is a low code, visual interface for composing multi agent reasoning loops without writing a line of Python. When a prototype needs deeper customisation, the logic can be exported directly into the Agent Development Kit (ADK), a code first, model agnostic framework that makes building agents feel like regular software engineering.

ADK has had a significant upgrade. More than six trillion tokens flow through Gemini models via ADK every month, which gives Google a lot of real world signal. The new graph based framework lets you organise agents into networks of sub agents with clear, deterministic logic for how they hand off work. Secure by design workspaces give each agent a sandboxed environment to run bash commands and manage files without touching core systems. Multimodal streaming support brings stable live audio and video interaction into the same framework.

For teams that do not want to start from scratch, Agent Garden provides pre built templates for things like code modernization, financial analysis, economic research and invoice processing. These act as building blocks you can stitch together into your own multi agent system.

Scale, surviving contact with production

Running an agent in a notebook is easy. Running one that handles real workloads for days at a time is not. The re engineered Agent Runtime is the execution layer that makes this possible. It delivers sub second cold starts, provisions new agents in seconds, and supports long running agents that can maintain state and reason across multi day workflows. Think of a sales prospecting sequence that nurtures a lead for two weeks, or a research agent that keeps refining its findings as new data arrives.

Persistent context is handled by Memory Bank. Instead of relying on temporary session data that disappears when a conversation ends, Memory Bank dynamically generates and curates long term memories from interactions. New Memory Profiles allow agents to recall high accuracy details with low latency. Payhawk, for example, uses Memory Bank so its Financial Controller Agent remembers user habits and auto submits expenses, cutting submission time by more than half.

Other scaling features worth flagging:

  • Agent Sandbox provides a hardened environment for executing model generated code or doing browser based automation without risk to host systems.
  • Agent Sessions with custom session IDs let you map conversations directly to your internal database or CRM records.
  • Bidirectional Streaming over WebSocket keeps live audio and video interactions responsive.
  • Agent to agent orchestration supports both generative and deterministic patterns, so critical flows like compliance checks follow exact paths every time.

Govern, every agent gets an identity

This is where Agent Platform distances itself from simpler agent frameworks. Governance is not a bolt on, it is structural.

Agent Identity assigns every agent a unique cryptographic ID. Each action an agent takes is therefore auditable and mapped back to defined authorization policies. Agent Registry acts as the single source of truth, indexing every internal agent, tool and skill so your teams only discover approved assets. Agent Gateway is the air traffic control layer, providing unified connectivity between agents and tools across any environment while enforcing security policies and Model Armor protections against prompt injection and data leakage.

On top of that, security intelligence runs continuously. Agent Anomaly Detection uses statistical models and an LLM as a judge framework to flag unusual reasoning. Agent Threat Detection watches for malicious activity like reverse shells or connections to suspicious IP addresses. A new Agent Security dashboard, powered by Security Command Center, unifies threat detection, risk analysis and vulnerability scanning across the operating system and language packages that underpin your agents.

The result is that whether an agent was built in house or sourced from a partner, it operates within the same enterprise guardrails.

Optimize, measure and refine

Shipping an agent is not the finish line. Agent Simulation lets you test agents against synthetic users and virtualized tools before release, scoring them automatically on task success and safety across multi step conversations. Agent Evaluation continuously scores agents against live traffic using multi turn autoraters that assess the logic of an entire conversation rather than a single reply. Agent Observability adds visual traces so engineers can debug complex reasoning as it happens.

The most interesting tool here is Agent Optimizer. Instead of manually digging through logs when an agent misbehaves, it automatically clusters real world failures and suggests refined system instructions. That closes the loop between production data and agent improvement without a human having to eyeball thousands of traces.

What this looks like in practice

The customer stories Google shared illustrate the range of use cases the platform targets:

  • Color Health built its Color Assistant with ADK and scales it through Agent Runtime to help more women access breast cancer screening, handling eligibility checks, clinician connections and scheduling in real time.
  • Comcast rebuilt its Xfinity Assistant as a multi agent architecture on ADK and Agent Runtime, moving from scripted automation to personalized, grounded troubleshooting.
  • Burns & McDonnell turns decades of engineering project data into actionable intelligence by combining deterministic business rules with probabilistic reasoning.
  • L’Oréal built a proprietary Beauty Tech Agentic Platform using ADK, connecting agents securely through Model Context Protocol to its internal data platform and operational systems.
  • Gurunavi uses Memory Bank in its UMAME restaurant discovery app so the agent remembers user preferences and proactively suggests options, eliminating manual search.
  • PayPal deploys agents for secure agent based commerce, using the Agent Payment Protocol as the trust foundation for transactions.

What ties these examples together is not the fact that they use generative AI. It is that each organisation is delegating an outcome to an agent rather than just a task, and doing so at a scale where governance, memory and orchestration are genuine requirements.

Where developers actually start

If you are new to the stack, the most natural path is Agent Studio for initial design, then ADK for deeper logic, then Agent Runtime for deployment. Alongside that you will want to understand:

  • RAG Engine for grounding agents in your private data and reducing hallucinations.
  • Vector Search for AI native retrieval over your enterprise content.
  • Agent Platform Sessions and Memory Bank for stateful, long running interactions.
  • Agent Gateway and Identity & IAM for routing, permissions and policy enforcement.
  • Traces, Topology and Offline Evaluations for understanding and improving agent behaviour over time.

There is also a programmatic interface that lets coding agents themselves build, evaluate and deploy new agents. In other words, AI that ships AI. That sounds recursive, and it is, but it also matches where serious engineering teams are heading as they try to compress the time from idea to production.

The bigger shift worth noticing

Most agent platforms so far have optimised for speed of prototyping. Agent Platform is optimised for what happens after the prototype works, which is arguably the harder problem. Giving every agent a verifiable identity, enforcing policy at a gateway, persisting memory with profiles, and automating refinement based on production failures are the kinds of features that matter when an agent is no longer a novelty but a dependency.

The practical takeaway is straightforward. If your agents are starting to touch real systems, real customers or real money, the bottleneck stops being model quality and starts being the operational layer around the model. That is the gap Gemini Enterprise Agent Platform is built to close, and it is worth studying even if your current stack sits elsewhere, because the categories it defines, identity, registry, gateway, runtime, memory, simulation, optimizer, are likely to become the default vocabulary for enterprise agents regardless of which vendor you end up choosing.