The best of Cloud Next '26: Gemini Enterprise Agent Platform. The perfect combination of Intelligence and Automation to generate VALUE.

The question being asked was: "How do we build an Agent?", but now the question is: "How do we manage thousands of Agents?". The answer that was found is: Gemini Enterprise Agent Platform.

The Future of Agentic AI: Gemini Enterprice Agent Platform

According to Sundar Pichai, everything is moving toward the unification of fundamental pillars and the next wave of innovation. Google is in the Gemini Era, the Era of Agency. Gemini Enterprise has been the gateway to AI with the capability to manage agents within the workplace environment.

The pace of technological change since last year’s Cloud Next has never been faster, and Google Cloud has incredible momentum.

Our first-party models now process more than 16 billion tokens per minute via direct API use by our customers, up from 10 billion last quarter. To support and drive this growth, in 2026, just over half of our overall machine learning compute investment is expected to go towards the Cloud business to benefit our cloud customers and partners.

Four very important areas

1. The Gemini Enterprise Agent Platform
Google Cloud has officially entered the Agentic Era, moving beyond simple chat to a "mission control" for the enterprise.

Scale & Momentum: Monthly active users grew by 40% in Q1 2026. First-party models now process 16 billion tokens per minute.

The Mission: The new Gemini Enterprise Agent Platform acts as the "connective tissue" between data, people, and goals. It allows organizations to Build, Scale, Govern, and Optimize thousands of agents with architectural rigor.

2. AI-Powered Cybersecurity
Security is being revolutionized through a partnership between Google’s Threat Intelligence and Wiz.

Autonomous Protection: The launch of Wiz’s AI-APP provides protection from code to runtime across hybrid and multi-cloud environments.

Real-World Impact: Internal SOC agents now triage tens of thousands of threat reports monthly, reducing mitigation time by over 90%.

3. Next-Gen Infrastructure: TPU v8
To power millions of concurrent agents, Google is launching its eighth-generation Tensor Processing Units with a dual-chip strategy:

TPU 8t (Training): Delivers 3x the processing power of the previous generation (Ironwood) and 2x better performance-per-watt.

TPU 8i (Inference): Optimized for massive throughput and low latency, essential for running complex agentic workloads cost-effectively at scale.

4. "Customer Zero": Proof of Performance
Google is using its own agentic technology to drive massive internal efficiencies:

Coding: 75% of new code at Google is now AI-generated. Complex code migrations are being completed 6x faster than a year ago.

Speed to Market: Using agents for creative asset generation resulted in 70% faster turnaround and a 20% increase in conversions for the Gemini in Chrome launch.

Key Takeaway for Businesses

The value has shifted from the models themselves to the execution of mission-critical tasks. Whether it's migrating code in days instead of months or automating threat response, the Gemini Enterprise Agent Platform is the engine turning strategy into autonomous action.

Gemini Enterprice: The Best of Google AI for every employee, for every workflow

According to Thomas Kurian, Gemini Enterprise is now the Integrated System for the AI Agent Era, serving as the link between data, people, and their goals or objectives. So, Gemini Enterprise combines INTELLIGENCE and AUTOMATION to generate VALUE. For it to work, context and action are required. Intelligence comes from data, and automation is driven by agents. Everything is coming together to form the large-scale equation that only a complete, integrated system can solve.

That Complete Integrated System has the following layers:

• Agentic Taskforce: Preconfigured specialized agents ready for business.
• Agentic Platform and Models: The system for building, deploying, and managing agents.
• Agentic Defense: Autonomous protection that secures the entire lifecycle of your AI.
• Agentic Data Cloud: The engine that provides reliable business context for the Agent System.
• AI Hypercomputer: A foundation designed and optimized for the physics of the Agent Era.

The Gemini Enterprise Agent Platform is the convergence environment for business logic, data, and models to drive autonomous actions, expanding Vertex AI capabilities and incorporating new functionalities so the team can BUIL, SCALE, GOVERN, and OPTIMIZE agents with the same architectural rigor applied to mission-critical business solution systems.

The importance of the Gemini Enterprise Agent Platform for business operations.

Agent Platform helps you move from managing individual AI tasks to delegating business outcomes with total confidence. You can:

1. BUILD:
   Shows a design environment where you can create agents by dragging logic modules and selecting models.

2. SCALE:
   Visualizes thousands of agents multiplying across a digital city, powered by TPUs and Axion for massive deployment.

3. GOVERN:
   Presents a centralized control panel with monitoring, access control, and security (Agentic Defense) for the entire agent fleet.

4. OPTIMIZE:
   Shows performance analytics, A/B testing, and cost metrics to continuously improve the efficiency of agentic operations.

Everything is built on the most advanced models, such as Gemini 3.1 Pro (in preview), which is the most advanced reasoning model optimized for complex workflow orchestration. Gemini 3.1 Pro closes the gap between strategy and autonomous execution, interacting with APIs and systems with minimal configuration.
For image generation, there is Gemini 3.1 Flash Image, also known as Nano Banana 2, for high-fidelity visual imagery.

Veo 3.1 Lite is the most cost-effective video model for creating high-volume video applications.

Lyria 3 Pro is the next-generation model for professional and enterprise-grade audio and music.

Models from Anthropic, such as Claude Opus, Sonnet, and Haiku, are also available.

BEYOND MODELS THAT REPRESENT A MAJOR ADVANCE OR A HUGE LEAP, YOU CAN SEE THAT THE MOST IMPORTANT FACTOR—ITS TRUE VALUE—LIES IN PUTTING THEM INTO PRACTICE TO OBTAIN SOLUTIONS FOR MISSION-CRITICAL PROBLEMS.

Customers using Gemini Enterprise Agent Platform:

So in summary: Gemini Enterprise Agent Platform is our open and comprehensive platform that empowers businesses to rapidly build, scale, govern and optimize enterprise-grade agents grounded in your enterprise data. It provides the full-stack foundation and extensive developer choice you need to transform your applications and workflows into powerful, reliable agentic systems at global scale.

Be Welcome and Get Started with Gemini Enterprice Agent Platform

The Quick Start Guide shows you how to install the Google Gen AI SDK for your preferred language, and then how to make your first API request.

1. Choose your authentication method
   You can authenticate to Gemini Enterprise Agent Platform by using Application Default Credentials (ADC) or by using an API key. ADC is the recommended method.

2. Before you begin
   Set up ADC by using a setup script or complete the steps manually.
   For Windows:
   

powershell -c "iex (irm https://storage.googleapis.com/cloud-samples-data/adc/setup_adc.ps1)"

1. Set up required roles If you're using a standard API key or ADC, your project also needs to be granted the appropriate Identity and Access Management permissions for Gemini Enterprise Agent Platform. If you're using an express mode API key, you can skip to the next step.

To get the permissions that you need to use Gemini Enterprise Agent Platform, ask your administrator to grant you the Agent Platform User (roles/aiplatform.user) IAM role on your project. For more information about granting roles, see Manage access to projects, folders, and organizations.

You might also be able to get the required permissions through custom roles or other predefined roles.

1. Install the SDK and set up your environment On your local machine, click one of the following tabs to install the SDK for your programming language. Install and update the Gen AI SDK for Java, for example, by running this command. Maven Add the following to your pom.xml:

<dependencies>
  <dependency>
    <groupId>com.google.genai</groupId>
    <artifactId>google-genai</artifactId>
    <version>0.7.0</version>
  </dependency>
</dependencies>

Set environment variables:

# Replace the `GOOGLE_CLOUD_PROJECT_ID` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT_ID
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True

1. Make your first request Use the generateContent method to send a request to the Gemini API in Gemini Enterprise Agent Platform.

The following examples show how to make a request using one of the SDKs or REST. To run an SDK example, copy the code to a file (for example, request.java) and run the file from your terminal (for example, java request.java).

import com.google.genai.Client;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HttpOptions;

public class TextGenerationWithText {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash";
    generateContent(modelId);
  }

  // Generates text with text input
  public static String generateContent(String modelId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      GenerateContentResponse response =
          client.models.generateContent(modelId, "How does AI work?", null);

      System.out.print(response.text());
      // Example response:
      // Okay, let's break down how AI works. It's a broad field, so I'll focus on the ...
      //
      // Here's a simplified overview:
      // ...
      return response.text();
    }
  }
}

1. Generate images

import com.google.genai.Client;
import com.google.genai.types.Blob;
import com.google.genai.types.Candidate;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.Part;
import com.google.genai.types.SafetySetting;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;

public class ImageGenMmFlashWithText {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash-image";
    String outputFile = "resources/output/example-image-eiffel-tower.png";
    generateContent(modelId, outputFile);
  }

  // Generates an image with text input
  public static void generateContent(String modelId, String outputFile) throws IOException {
    // Client Initialization. Once created, it can be reused for multiple requests.
    try (Client client = Client.builder().location("global").vertexAI(true).build()) {

      GenerateContentConfig contentConfig =
          GenerateContentConfig.builder()
              .responseModalities("TEXT", "IMAGE")
              .candidateCount(1)
              .safetySettings(
                  SafetySetting.builder()
                      .method("PROBABILITY")
                      .category("HARM_CATEGORY_DANGEROUS_CONTENT")
                      .threshold("BLOCK_MEDIUM_AND_ABOVE")
                      .build())
              .build();

      GenerateContentResponse response =
          client.models.generateContent(
              modelId,
              "Generate an image of the Eiffel tower with fireworks in the background.",
              contentConfig);

      // Get parts of the response
      List<Part> parts =
          response
              .candidates()
              .flatMap(candidates -> candidates.stream().findFirst())
              .flatMap(Candidate::content)
              .flatMap(Content::parts)
              .orElse(new ArrayList<>());

      // For each part print text if present, otherwise read image data if present and
      // write it to the output file
      for (Part part : parts) {
        if (part.text().isPresent()) {
          System.out.println(part.text().get());
        } else if (part.inlineData().flatMap(Blob::data).isPresent()) {
          BufferedImage image =
              ImageIO.read(new ByteArrayInputStream(part.inlineData().flatMap(Blob::data).get()));
          ImageIO.write(image, "png", new File(outputFile));
        }
      }

      System.out.println("Content written to: " + outputFile);
      // Example response:
      // Here is the Eiffel Tower with fireworks in the background...
      //
      // Content written to: resources/output/example-image-eiffel-tower.png
    }
  }
}

1. Understand images Gemini can understand images as well. The following code uses the image generated in the previous section and uses a different model to infer information about the image:

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HttpOptions;
import com.google.genai.types.Part;

public class TextGenerationWithTextAndImage {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash";
    generateContent(modelId);
  }

  // Generates text with text and image input
  public static String generateContent(String modelId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      GenerateContentResponse response =
          client.models.generateContent(
              modelId,
              Content.fromParts(
                  Part.fromText("What is shown in this image?"),
                  Part.fromUri(
                      "gs://cloud-samples-data/generative-ai/image/scones.jpg", "image/jpeg")),
              null);

      System.out.print(response.text());
      // Example response:
      // The image shows a flat lay of blueberry scones arranged on parchment paper. There are ...
      return response.text();
    }
  }
}

1. Use code execution The Gemini API in Gemini Enterprise Agent Platform code execution feature enables the model to generate and run Python code and learn iteratively from the results until it arrives at a final output. Gemini Enterprise Agent Platform provides code execution as a tool, similar to function calling. You can use this code execution capability to build applications that benefit from code-based reasoning and that produce text output. For example:

import com.google.genai.Client;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HttpOptions;
import com.google.genai.types.Tool;
import com.google.genai.types.ToolCodeExecution;

public class ToolsCodeExecWithText {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash";
    generateContent(modelId);
  }

  // Generates text using the Code Execution tool
  public static String generateContent(String modelId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      // Create a GenerateContentConfig and set codeExecution tool
      GenerateContentConfig contentConfig =
          GenerateContentConfig.builder()
              .tools(Tool.builder().codeExecution(ToolCodeExecution.builder().build()).build())
              .temperature(0.0F)
              .build();

      GenerateContentResponse response =
          client.models.generateContent(
              modelId,
              "Calculate 20th fibonacci number. Then find the nearest palindrome to it.",
              contentConfig);

      System.out.println("Code: 
" + response.executableCode());
      System.out.println("Outcome: 
" + response.codeExecutionResult());
      // Example response
      // Code:
      // def fibonacci(n):
      //    if n <= 0:
      //        return 0
      //    elif n == 1:
      //        return 1
      //    else:
      //        a, b = 1, 1
      //        for _ in range(2, n):
      //            a, b = b, a + b
      //        return b
      //
      // fib_20 = fibonacci(20)
      // print(f'{fib_20=}')
      //
      // Outcome:
      // fib_20=6765
      return response.executableCode();
    }
  }
}

To implement the Gemini Enterprise Agent Platform with the architectural rigor required for mission-critical solutions, the process is divided into four strategic phases. Here is your detailed step-by-step

To implement the Gemini Enterprise Agent Platform with the architectural rigor required for mission-critical solutions, the process is divided into four strategic phases. Here is your detailed step-by-step guide:

Phase 1: Infrastructure Setup in Vertex AI
Before building, you must prepare the Google Cloud environment to ensure agents have access to the necessary resources.

Enable Vertex AI: Access your Google Cloud Console and activate the Vertex AI API.

Configure the Knowledge Catalog: Connect your data sources (BigQuery, Cloud Storage, or third-party APIs) so the agent has a "grounded" knowledge base to reason from.

Select the Base Model: Choose Gemini 3.1 Pro for tasks requiring complex reasoning or orchestration, or Gemini 3.1 Flash for tasks requiring low latency and high speed.

Phase 2: BUILD (Agent Construction)
This is where business logic meets the AI model.

Define "System Instructions": Establish the agent's role, its tone, and its operational boundaries.

Configure Tool Use (Function Calling): Define the APIs and tools the agent is authorized to "touch"—for example, connecting it to an inventory system or a payment gateway.

Flow Design (Agent Designer): Use the low-code interface to drag and drop logic modules that dictate how the agent should behave in different scenarios.

Phase 3: GOVERN & SCALE (Governance and Scaling)
Once built, the agent must operate under enterprise-grade standards.

Apply Agentic Defense: Configure security layers to filter content, prevent hallucinations, and protect sensitive customer data.

Establish RBAC (Role-Based Access Control): Define who can modify the agent and what specific data each agent instance is allowed to query.

Massive Deployment: Leverage TPU 8i infrastructure and Axion processors so the agent can handle millions of concurrent interactions without performance degradation.

Phase 4: OPTIMIZE (Continuous Optimization)
The work doesn't end at deployment; the agent must learn from the real world.

Real-Time Monitoring: Review the Performance Analytics dashboard to measure latency and success rates for completed tasks.

A/B Testing: Deploy two versions of the same agent to compare which one better resolves user issues.

Close the Feedback Loop: Use interaction data to refine instructions and retrain the logic, ensuring autonomous execution becomes increasingly precise.

Critical note:

Remember that the key to this platform, beyond chats, is being able to execute actions on critical systems with minimal configuration.

Final Conclusion:

The Final Conclusion effectively captures the paradigm shift from traditional AI to a fully autonomous enterprise.

The Engine of the Agentic Enterprise
The Gemini Enterprise Agent Platform is far more than a simple chat interface; it is the connective tissue that allows organizations to scale their operational capacity exponentially. By integrating the Gemini 3.1 model family with unprecedented hardware infrastructure (TPU v8), Google has solved the core challenge of the "Agentic Era": moving from experimental prototypes to the orchestration of thousands of autonomous agents.

Key Strategic Takeaways:
From Conversation to Execution: The platform's true value lies in its ability to perform mission-critical actions—ranging from automated code migrations to real-time cybersecurity defense—with autonomy and enterprise-grade security.

Architectural Rigor: Through the stages of Building, Governing, Scaling, and Optimizing, the platform ensures that AI is not a "black box," but a controlled, auditable, and highly efficient business asset.

Proven Real-World Impact: With massive adoption by global leaders like Goldman Sachs, Ford, and L'Oréal, the platform has demonstrated it can reduce threat mitigation times by over 90% and accelerate software development by up to 6 times.

Final Reflection
We are witnessing a shift where a company’s success will no longer be measured solely by its human talent or data, but by the efficiency of its digital workforce. The Gemini Enterprise Agent Platform is the "mission control" that empowers business leaders to orchestrate that workforce with total confidence, security, and global scale.

"The question is no longer whether you can build an agent, but how fast you can deploy thousands of them to transform your business."