Agent Runtime on Gemini Enterprise Agent Platform: How to Deploy, Scale, and Operate AI Agents in Production

Building an agent that works on a laptop is the easy part. Running it for thousands of users (with versioning, rollbacks, memory, security controls, and monitoring) is where most agent projects stall. Agent Runtime (formerly Vertex AI Agent Engine) is Google’s managed answer to that problem.

Agent Runtime is part of Gemini Enterprise Agent Platform (formerly Vertex AI) and was called Vertex AI Agent Engine until April 2026. This guide covers what it provides, the five ways to deploy, revisions and traffic splitting, sessions and memory, security, observability, and a production checklist.

If you haven’t built an agent yet, start with our ADK tutorial or Agent Studio guide, then come back here to ship it.

It’s the runtime behind many agents that employees use through Gemini Enterprise and Google Workspace.

Key Takeaways

• Agent Runtime (formerly Agent Engine) runs agents for up to seven days with sub-second cold starts.
• Five deployment methods cover notebooks, Git, source files, Dockerfiles, and container images.
• Revisions and traffic splitting enable canary rollouts (Preview).
• Enable Agent Identity, Private Service Connect, and VPC-SC for production.
• Alert on error rate, latency, tool failures, and cost.

Table of contents

Open Table of contents

• What Agent Runtime Provides
• The Five Deployment Methods
• Revisions and Traffic Splitting
• Sessions and Memory
• Security and Compliance
• Observability
• Cost Control
• Agent Runtime vs. Cloud Run vs. GKE
• Production Readiness Checklist
• Publishing to Employees
• Conclusion

What Agent Runtime Provides

Google describes Agent Runtime as a fully managed environment for deploying and scaling agents without managing infrastructure. Its main capabilities:

Supported frameworks

ADK, Agent2Agent, LangChain, LangGraph, AG2, LlamaIndex, and custom agents. With container-based deployment, any language works.

---

The Five Deployment Methods

The SDK uses client.runtimes.create() for all five. A few examples from Google’s documentation:

From a Git repository (Developer Connect):

remote_agent = client.runtimes.create(
    config={
        "developer_connect_source": {
            "git_repository_link": "projects/PROJECT_ID/locations/LOCATION/connections/CONNECTION_ID/gitRepositoryLinks/REPO_ID",
            "revision": "main",
            "dir": "path/to/dir",
        },
        "entrypoint_module": "agent",
        "entrypoint_object": "root_agent",
    },
)

From a prebuilt container:

remote_agent = client.runtimes.create(
    config={
        "container_spec": {
            "image_uri": "us-central1-docker.pkg.dev/my-project/my-repo/my-image:tag",
        },
        "display_name": "Container image agent",
    },
)

The returned object is an AgentRuntime, and the underlying API resource is still a reasoningEngines resource: one of several places where pre-rename names live on in the API.

ADK shortcut: ADK users can skip the SDK and run adk deploy agent_engine --project=... --region=... --display_name="..." my_agent.

Which method should you choose?

• Prototyping in a notebook → Agent Platform SDK
• Python agents with CI/CD → Developer Connect or source files
• Non-Python agents or custom servers → Dockerfile or container image
• Strict change control → container image, built and scanned in your pipeline, then deployed by tag

---

Revisions and Traffic Splitting

Every time you create an agent or change its versioned fields, Agent Runtime creates an immutable revision. This feature is in Preview (v1beta1 API).

A safe rollout

1. Deploy the new revision
2. Send 10% of traffic to it and 90% to the current revision
3. Watch errors, latency, evaluation scores, and cost for a day
4. Move to 50%, then 100%
5. If something goes wrong, shift traffic back to the previous active revision

In the console: Govern → Deployments → your agent → Revisions → Manage traffic. In the SDK, call client.runtimes.update() with a traffic_config.

Limits and gotchas

• Up to 950 revisions per agent and 6,000 per project per region (not adjustable)
• Automatic cleanup removes old revisions only if they’re active with 0% traffic
• Queries sent directly to a specific revision bypass traffic rules: useful for testing
• Changing the Agent Gateway binding archives all existing revisions, and requires all traffic on the latest revision first. Plan gateway changes as a deliberate cutover.

---

Sessions and Memory

Agents need two kinds of memory:

Custom session IDs let you map sessions to records in your CRM or database. Memory Bank can extract memories using structured schemas you define, and Memory Profiles give low-latency recall. We’ll cover Memory Bank in depth later in this series.

Billing note: since September 1, 2026, session and Memory Bank compute is metered on the Agent Platform compute SKU, and Memory Bank embedding SKUs changed. Watch for these line items.

---

Security and Compliance

Google lists these enterprise controls for Agent Runtime:

Plus:

• Agent Identity: each agent gets its own IAM principal, so you grant permissions to the agent rather than to a shared service account, and audit logs show exactly which agent acted
• Private Service Connect interfaces: connect agents to your VPC and control their internet access
• Agent Gateway: route traffic through a central policy point with Model Armor protection
• Secrets: store keys in Secret Manager; when you pass secrets as environment variables with an agent identity, grant roles/secretmanager.secretAccessor to the Agent Platform Service Agent, which reads the secret values during deployment

Least privilege in practice: if an agent only reads one BigQuery dataset and writes to one Cloud Storage bucket, its identity should have exactly those two permissions. Nothing at project level.

---

Observability

Agent Runtime integrates with Google Cloud’s operations tools:

• Cloud Trace: trace query response times and each operation inside an agent run
• Cloud Logging: agent and framework logs
• Metrics and alerts: built-in metrics, custom metrics, and alerting
• ADK telemetry metrics: available for ADK 2.6.0 and later (added August 2026)

On top of this, Agent Platform’s Agent Observability provides turnkey dashboards and execution traces, and Agent evaluation can score live traffic for quality drift.

What to alert on

---

Cost Control

Agent Runtime is a paid service. You pay for the runtime resources your agents use, model tokens, and (since September 2026) session and Memory Bank compute. To keep costs predictable:

• One project per agent or team, with a Cloud Billing budget and spend cap
• Right-size models: route simple steps to faster, cheaper models
• Cap long-running jobs: set your own time and step limits, even though the platform allows up to seven days
• Clean up: delete unused agents and archived revisions’ dependencies

For how Gemini Enterprise and Agent Platform charges appear on invoices, see our billing guide.

---

Agent Runtime vs. Cloud Run vs. GKE

ADK agents can also run on Cloud Run or Google Kubernetes Engine. When is the managed runtime worth it?

For most teams, Agent Runtime is the default: it removes the plumbing (state, memory, identity, gateway routing) that otherwise takes weeks to build. Cloud Run makes sense when the agent is one endpoint inside a larger service you already run there. GKE fits organizations that standardize everything on Kubernetes or need fine control over hardware and networking.

---

Production Readiness Checklist

---

Publishing to Employees

Agents on Agent Runtime can be registered in Agent Registry and made available to employees through the Gemini Enterprise app, where people already search company data and use the Gemini agent. Your own full-code agents require the Standard, Plus, Pay-as-you-go, or Frontline (provisioned agents) editions.

---

Conclusion

Agent Runtime turns an agent from a demo into a service: five deployment paths to fit your pipeline, immutable revisions with traffic splitting for safe rollouts, sessions and Memory Bank for context, long-running jobs of up to seven days, and the security controls regulated teams expect. The API still speaks in reasoningEngines and the ADK command still says agent_engine, but the platform behind them has grown up considerably.

Treat agents like any other production service (pipelines, least privilege, canaries, alerts, and budgets) and they’ll be ready to serve the people across your organization, including teams working in Google Workspace through Gemini Enterprise.

---

Official Google documentation:

• Scale agents with Agent Runtime
• Deploy an agent
• Manage revisions and traffic
• Agent Platform release notes

Related reading:

• Google Agent Development Kit (ADK) Tutorial: build the agent you deploy here.
• Agent Studio: Build AI Agents Visually: design and deploy from the console.
• Vertex AI Is Now Gemini Enterprise Agent Platform: why Agent Engine became Agent Runtime.