> ## AI Agent Context
> Get the complete documentation index at: https://aistudio.google.com/docs/llms.txt
> Use this file to discover all available pages.
> For the full documentation in a single file, fetch: https://aistudio.google.com/docs/llms-full.txt

# Computer use

The Computer Use tool lets you build browser, mobile, and desktop control agents
that interact with and automate tasks. Using screenshots, the model can "see" a
computer screen, and "act" by generating specific UI actions like mouse clicks
and keyboard inputs. Similar to function calling, you will need to implement the
client-side execution environment to receive and execute the Computer Use
actions.

For the list of supported models, see
[Model versions](/docs/computer-use#model-versions). Gemini 4 and Gemini 3.x
models support several advanced capabilities:

* **Multi-environment support:** build agents for [browser, mobile, and desktop](/docs/computer-use#supported-environments) environments.
* **Streamlined actions with intents:** actions include an `intent` field that explains the model's reasoning behind each step.
* **Configurable safety policies:** fine-tune [safety behavior](/docs/computer-use#safety-policies) with built-in policy categories and overrides.
* **Prompt injection detection:** opt-in [screenshot scanning](/docs/computer-use#prompt-injection) to detect hidden adversarial instructions.

With Computer Use, you can build agents that:

* Automate repetitive data entry or form filling on websites.
* Perform automated testing of web applications and user flows
* Conduct research across various websites (e.g., gathering product
  information, prices, and reviews from ecommerce sites to inform a purchase)

Here's a minimal example of initializing the client and sending a prompt to the model with the `computer_use` tool enabled for a browser environment:

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  from google import genai
  
  client = genai.Client()
  
  interaction = client.interactions.create(
      model="gemini-3.8-flash",
      input="Search for 'Gemini API' on Google.",
      tools=[{"type": "computer_use", "environment": "browser"}]
  )
  
  print(interaction)
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from '@google/genai';
  
  const ai = new GoogleGenAI();
  
  const interaction = await ai.interactions.create({
    model: 'gemini-3.8-flash',
    input: "Search for 'Gemini API' on Google.",
    tools: [{ type: "computer_use", environment: "browser" }]
  });
  
  console.log(interaction);
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.gaos.models.interactions.ComputerUse;
  import com.google.genai.gaos.models.interactions.CreateModelInteraction;
  import com.google.genai.gaos.models.interactions.EnvironmentEnum;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.Arrays;
  
  Client client = new Client();
  
  CreateModelInteraction params =
      CreateModelInteraction.builder()
          .model("gemini-3.8-flash")
          .input(InteractionsInput.of("Search for 'Gemini API' on Google."))
          .tools(
              Arrays.asList(
                  ComputerUse.builder().environment(EnvironmentEnum.BROWSER).build()))
          .build();
  
  Interaction interaction =
      client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  
  System.out.println(interaction);
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "fmt"
      "log"
  
      "google.golang.org/genai"
      "google.golang.org/genai/interactions/models/interactions"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      client, err := genai.NewClient(ctx, nil)
      if err != nil {
          log.Fatal(err)
      }
  
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
              Model: interactions.Model("gemini-3.8-flash"),
              Input: interactions.NewInteractionsInput("Search for 'Gemini API' on Google."),
              Tools: []interactions.Tool{
                  interactions.NewTool(interactions.ComputerUse{
                      Environment: interactions.EnvironmentEnumBrowser.ToPointer(),
                  }),
              },
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  
      fmt.Println(res.Interaction)
  }
  ```

  {% /tab %}

{% /tabs %}

{% callout type="note" %}
  Computer Use may contain errors and security
  vulnerabilities. We recommend supervising closely for important tasks, and that
  you avoid using the Computer Use capability for tasks involving critical
  decisions, sensitive data, or actions where serious errors cannot be corrected.
  We encourage you to review the [Safety best practices](/docs/computer-use#safety-best-practices),
  the [Prohibited Use
  Policy](https://policies.google.com/terms/generative-ai/use-policy) and [Gemini
  API Additional Terms of Service](/docs/terms).

{% /callout %}

## How Computer Use works  {% id="how-computer-use" %}

To build an agent with the Computer Use model, you need to set up a
continuous loop between your application and the API. Here is what your code
will do at each step:

1. [**Send a request to the model**](/docs/computer-use#send-request)  *  Your application sends an API request containing the Computer Use tool,
    your configuration settings (like the target environment), the user's
    prompt, and a screenshot of the current screen.

2. [**Receive the model response**](/docs/computer-use#model-response)  *  The model analyzes the screen and the prompt, returning a response
    which includes a suggested `function_call` representing a UI action (such
    as a click, scroll, or keystroke).
  *    For **Gemini 4 and Gemini 3.x models**, the response also includes a
    reasoning `intent` explaining why the model chose that action.
  *  The response may also include a `safety_decision` from an internal safety
    system that classifies the action as regular/allowed,
    `require_confirmation` (requiring user approval), or blocked.

3. [**Execute the received action**](/docs/computer-use#execute-actions)  *  If the action is allowed (or the user confirms it), your client-side
    code parses the `function_call`, scales the normalized coordinates to match
    your viewport, and executes the action in your target environment using
    automation tools (such as Playwright). If the action is blocked, your
    client should halt the execution or handle the interruption.

4. [**Capture the new environment state**](/docs/computer-use#capture-state)  *  After the action finishes executing, your application captures a new
    screenshot and sends it back to the model in a `function_result` to
    request the next step.


This process then repeats from step 2, continually soliciting the next action
from the model until the task is completed or terminated.

![](https://www.gstatic.com/cloud-cms/1360b1ef687451ea91ed7780b9766e90.png)

## How to implement Computer Use  {% id="implement-computer-use" %}

Before building with the Computer Use tool you will need to set up:

* **Secure execution environment:** Run your agent in a sandboxed VM or
  container to isolate it from your host system and limit its potential impact.
  The [reference implementation](https://github.com/google/computer-use-preview/)
  includes a ready-to-use Docker-based sandbox you can use as a starting point.
* **Client-side action handler:** Implement client-side logic to execute coordinates, type text, and take screenshots.

The examples below use a web browser as the execution environment and
[Playwright](https://playwright.dev/) as the client-side handler.

### 0. Set up Playwright

First, install the required packages:

```bash
pip install google-genai playwright
playwright install chromium
```

Then, initialize a Playwright browser instance to use for execution:

```python
from playwright.sync_api import sync_playwright

# 1. Configure screen dimensions for the target environment
SCREEN_WIDTH = 1440
SCREEN_HEIGHT = 900

# 2. Start the Playwright browser
# In production, utilize a sandboxed environment.
playwright = sync_playwright().start()
# Set headless=False to see the actions performed on your screen
browser = playwright.chromium.launch(headless=False)

# 3. Create a context and page with the specified dimensions
context = browser.new_context(
    viewport={"width": SCREEN_WIDTH, "height": SCREEN_HEIGHT}
)
page = context.new_page()

# 4. Navigate to an initial page to start the task
page.goto("https://www.google.com")

# The 'page', 'SCREEN_WIDTH', and 'SCREEN_HEIGHT' variables
# will be used in the steps below.
```

### 1. Send a request to the model  {% id="send-request" %}

Initialize the client library and configure the Computer Use tool. Note that there is no need to specify the display size when issuing a request; the model predicts pixel coordinates scaled to the height and width of the screen.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  Use the `google-genai` Python SDK (version `2.7.0` or higher) to configure a request targeting the browser environment:

  ```python
  from google import genai
  
  client = genai.Client()
  
  interaction = client.interactions.create(
      model='gemini-3.8-flash',
      input="Find a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th",
      tools=[
          {
              "type": "computer_use",
              "environment": "browser",
              "enable_prompt_injection_detection": True
          }
      ]
  )
  
  print(interaction)
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  Use the `@google/genai` Node.js SDK to configure a request targeting the browser environment:

  ```javascript
  import { GoogleGenAI } from '@google/genai';
  
  const ai = new GoogleGenAI();
  
  const interaction = await ai.interactions.create({
    model: 'gemini-3.8-flash',
    input: "Find a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th",
    tools: [
      {
        type: "computer_use",
        environment: "browser",
        enable_prompt_injection_detection: true
      }
    ]
  });
  
  console.log(interaction);
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.gaos.models.interactions.ComputerUse;
  import com.google.genai.gaos.models.interactions.CreateModelInteraction;
  import com.google.genai.gaos.models.interactions.EnvironmentEnum;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.Arrays;
  
  Client client = new Client();
  
  CreateModelInteraction params =
      CreateModelInteraction.builder()
          .model("gemini-3.8-flash")
          .input(
              InteractionsInput.of(
                  "Find a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th"))
          .tools(
              Arrays.asList(
                  ComputerUse.builder()
                      .environment(EnvironmentEnum.BROWSER)
                      .enablePromptInjectionDetection(true)
                      .build()))
          .build();
  
  Interaction interaction =
      client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  
  System.out.println(interaction);
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "fmt"
      "log"
  
      "google.golang.org/genai"
      "google.golang.org/genai/interactions/models/interactions"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      client, err := genai.NewClient(ctx, nil)
      if err != nil {
          log.Fatal(err)
      }
  
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
              Model: interactions.Model("gemini-3.8-flash"),
              Input: interactions.NewInteractionsInput("Find a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th"),
              Tools: []interactions.Tool{
                  interactions.NewTool(interactions.ComputerUse{
                      Environment:                    interactions.EnvironmentEnumBrowser.ToPointer(),
                      EnablePromptInjectionDetection: genai.Ptr(true),
                  }),
              },
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  
      fmt.Println(res.Interaction)
  }
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  Use curl to send a request:

  ```shell
  curl -X POST \
    "https://generativelanguage.googleapis.com/v1/interactions" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gemini-3.8-flash",
      "input": "Find me a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th. Start by navigating directly to flights.google.com",
      "tools": [
        {
          "type": "computer_use",
          "environment": "browser",
          "enable_prompt_injection_detection": true
        }
      ]
    }'
  ```

  {% /tab %}

{% /tabs %}

### 2. Receive the model response  {% id="model-response" %}

The model response suggests a function call containing coordinates and a
tailored reasoning intent explaining the action:

```json
{
  "steps": [
    {
      "type": "function_call",
      "name": "click",
      "arguments": {
        "x": 450,
        "y": 120,
        "intent": "Click the search box to type the destination."
      }
    }
  ]
}
```

### 3. Execute the received actions  {% id="execute-actions" %}

Your application must parse the response coordinates, scale them from the normalized 1000x1000 coordinates, and execute the action:

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  from typing import Any, List, Tuple
  import time
  
  def denormalize_x(x: int, screen_width: int) -> int:
      """Convert normalized x coordinate (0-1000) to actual pixel coordinate."""
      return int(x / 1000 * screen_width)
  
  def denormalize_y(y: int, screen_height: int) -> int:
      """Convert normalized y coordinate (0-1000) to actual pixel coordinate."""
      return int(y / 1000 * screen_height)
  
  def execute_function_calls(interaction, page, screen_width, screen_height):
      results = []
      function_calls = [
          step for step in interaction.steps if step.type == "function_call"
      ]
  
      for function_call in function_calls:
          action_result = {}
          fname = function_call.name
          args = function_call.arguments
          print(f"  -> Executing: {fname} (Intent: {args.get('intent', 'N/A')})")
  
          try:
              if fname == "open_app":
                  pass # Handled / already open
              elif fname in ("click", "double_click", "triple_click", "middle_click", "right_click", "move", "long_press"):
                  actual_x = denormalize_x(args["x"], screen_width)
                  actual_y = denormalize_y(args["y"], screen_height)
  
                  if fname == "click":
                      page.mouse.click(actual_x, actual_y)
                  elif fname == "double_click":
                      page.mouse.dblclick(actual_x, actual_y)
                  elif fname == "right_click":
                      page.mouse.click(actual_x, actual_y, button="right")
                  elif fname == "middle_click":
                      page.mouse.click(actual_x, actual_y, button="middle")
                  elif fname == "move":
                      page.mouse.move(actual_x, actual_y)
              elif fname == "type":
                  actual_x = denormalize_x(args["x"], screen_width) if "x" in args else None
                  actual_y = denormalize_y(args["y"], screen_height) if "y" in args else None
                  text = args["text"]
                  press_enter = args.get("press_enter", False)
  
                  if actual_x is not None and actual_y is not None:
                      page.mouse.click(actual_x, actual_y)
                  # Clear field first
                  page.keyboard.press("Meta+A")
                  page.keyboard.press("Backspace")
                  page.keyboard.type(text)
                  if press_enter:
                      page.keyboard.press("Enter")
              elif fname == "navigate":
                  page.goto(args["url"])
              elif fname == "go_back":
                  page.go_back()
              elif fname == "go_forward":
                  page.go_forward()
              elif fname == "wait":
                  time.sleep(args.get("seconds", 1))
              else:
                  print(f"Warning: Custom or unhandled function {fname}")
  
              page.wait_for_load_state(timeout=5000)
              time.sleep(1)
  
          except Exception as e:
              print(f"Error executing {fname}: {e}")
              action_result = {"error": str(e)}
  
          results.append((fname, function_call.id, action_result))
  
      return results
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  function denormalizeX(x, screenWidth) {
      // Convert normalized x coordinate (0-1000) to actual pixel coordinate.
      return Math.floor((x / 1000) * screenWidth);
  }
  
  function denormalizeY(y, screenHeight) {
      // Convert normalized y coordinate (0-1000) to actual pixel coordinate.
      return Math.floor((y / 1000) * screenHeight);
  }
  
  async function executeFunctionCalls(interaction, page, screenWidth, screenHeight) {
      const results = [];
      const functionCalls = interaction.steps.filter(step => step.type === "function_call");
  
      for (const functionCall of functionCalls) {
          const actionResult = {};
          const fname = functionCall.name;
          const args = functionCall.arguments;
          console.log(`  -> Executing: ${fname} (Intent: ${args.intent || 'N/A'})`);
  
          try {
              if (fname === "open_app") {
                  // Handled / already open
              } else if (["click", "double_click", "triple_click", "middle_click", "right_click", "move", "long_press"].includes(fname)) {
                  const actualX = denormalizeX(args.x, screenWidth);
                  const actualY = denormalizeY(args.y, screenHeight);
  
                  if (fname === "click") {
                      await page.mouse.click(actualX, actualY);
                  } else if (fname === "double_click") {
                      await page.mouse.dblclick(actualX, actualY);
                  } else if (fname === "right_click") {
                      await page.mouse.click(actualX, actualY, { button: "right" });
                  } else if (fname === "middle_click") {
                      await page.mouse.click(actualX, actualY, { button: "middle" });
                  } else if (fname === "move") {
                      await page.mouse.move(actualX, actualY);
                  }
              } else if (fname === "type") {
                  const actualX = args.x !== undefined ? denormalizeX(args.x, screenWidth) : null;
                  const actualY = args.y !== undefined ? denormalizeY(args.y, screenHeight) : null;
                  const text = args.text;
                  const pressEnter = args.press_enter || false;
  
                  if (actualX !== null && actualY !== null) {
                      await page.mouse.click(actualX, actualY);
                  }
                  // Clear field first
                  await page.keyboard.press("Meta+A");
                  await page.keyboard.press("Backspace");
                  await page.keyboard.type(text);
                  if (pressEnter) {
                      await page.keyboard.press("Enter");
                  }
              } else if (fname === "navigate") {
                  await page.goto(args.url);
              } else if (fname === "go_back") {
                  await page.goBack();
              } else if (fname === "go_forward") {
                  await page.goForward();
              } else if (fname === "wait") {
                  await new Promise(resolve => setTimeout(resolve, (args.seconds || 1) * 1000));
              } else {
                  console.log(`Warning: Custom or unhandled function ${fname}`);
              }
  
              await page.waitForLoadState('load', { timeout: 5000 }).catch(() => {});
              await new Promise(resolve => setTimeout(resolve, 1000));
          } catch (e) {
              console.log(`Error executing ${fname}: ${e}`);
              actionResult.error = e.message;
          }
  
          results.push([fname, functionCall.id, actionResult]);
      }
  
      return results;
  }
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.gaos.models.interactions.FunctionCallStep;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.Step;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  class ActionExecutor {
    int denormalizeX(int x, int screenWidth) {
      return (int) (x / 1000.0 * screenWidth);
    }
  
    int denormalizeY(int y, int screenHeight) {
      return (int) (y / 1000.0 * screenHeight);
    }
  
    List<Map<String, Object>> executeFunctionCalls(
        Interaction interaction, int screenWidth, int screenHeight) {
      List<Map<String, Object>> results = new ArrayList<>();
  
      for (Step step : interaction.steps().orElse(Collections.emptyList())) {
        if (step instanceof FunctionCallStep) {
          FunctionCallStep functionCall = (FunctionCallStep) step;
          String fname = functionCall.name().orElse("");
          Map<String, Object> args = functionCall.arguments().orElse(Collections.emptyMap());
          Map<String, Object> actionResult = new HashMap<>();
  
          System.out.println(
              "  -> Executing: " + fname + " (Intent: " + args.getOrDefault("intent", "N/A") + ")");
  
          try {
            if (fname.equals("click")) {
              int actualX = denormalizeX(((Number) args.get("x")).intValue(), screenWidth);
              int actualY = denormalizeY(((Number) args.get("y")).intValue(), screenHeight);
              // Perform mouse click at (actualX, actualY) using your browser automation library
            } else if (fname.equals("type")) {
              String text = (String) args.get("text");
              // Type text into active element using your browser automation library
            } else if (fname.equals("navigate")) {
              String url = (String) args.get("url");
              // Navigate browser to url
            }
          } catch (Exception e) {
            actionResult.put("error", e.getMessage());
          }
  
          Map<String, Object> entry = new HashMap<>();
          entry.put("name", fname);
          entry.put("callId", functionCall.id().orElse(""));
          entry.put("result", actionResult);
          results.add(entry);
        }
      }
      return results;
    }
  }
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "fmt"
  
      "google.golang.org/genai/interactions/models/interactions"
  )
  
  func denormalizeX(x, screenWidth int) int {
      return int(float64(x) / 1000.0 * float64(screenWidth))
  }
  
  func denormalizeY(y, screenHeight int) int {
      return int(float64(y) / 1000.0 * float64(screenHeight))
  }
  
  func executeFunctionCalls(interaction *interactions.Interaction, screenWidth, screenHeight int) []map[string]any {
      var results []map[string]any
  
      for _, step := range interaction.Steps {
          if functionCall := step.FunctionCallStep; functionCall != nil {
              fname := functionCall.Name
              args := functionCall.Arguments
              actionResult := map[string]any{}
  
              intent := args["intent"]
              if intent == nil {
                  intent = "N/A"
              }
              fmt.Printf("  -> Executing: %s (Intent: %v)\n", fname, intent)
  
              switch fname {
              case "click":
                  xVal, _ := args["x"].(float64)
                  yVal, _ := args["y"].(float64)
                  actualX := denormalizeX(int(xVal), screenWidth)
                  actualY := denormalizeY(int(yVal), screenHeight)
                  _ = actualX
                  _ = actualY
                  // Perform mouse click at (actualX, actualY) using your browser automation library
              case "type":
                  text, _ := args["text"].(string)
                  _ = text
                  // Type text into active element using your browser automation library
              case "navigate":
                  url, _ := args["url"].(string)
                  _ = url
                  // Navigate browser to url
              }
  
              results = append(results, map[string]any{
                  "name":   fname,
                  "callId": functionCall.ID,
                  "result": actionResult,
              })
          }
      }
      return results
  }
  
  func main() {
      // Example helper usage with an Interaction response
  }
  ```

  {% /tab %}

{% /tabs %}

### 4. Capture the new environment state  {% id="capture-state" %}

After executing the actions, send the result of the function execution back to
the model so it can use this information to generate the next action. If
multiple actions (parallel calls) were executed, you must send a
`function_result` for each one in the subsequent user turn.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  import json
  import base64
  
  def get_function_responses(page, results):
      screenshot_bytes = page.screenshot(type="png")
      current_url = page.url
      function_responses = []
      for name, call_id, result in results:
          function_responses.append({
              "type": "function_result",
              "name": name,
              "call_id": call_id,
              "result": [
                  {
                      "type": "text",
                      "text": json.dumps({"url": current_url, **result})
                  },
                  {
                      "type": "image",
                      "data": base64.b64encode(screenshot_bytes).decode("utf-8"),
                      "mime_type": "image/png"
                  }
              ]
          })
      return function_responses
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  async function getFunctionResponses(page, results) {
      const screenshotBuffer = await page.screenshot({ type: 'png' });
      const screenshotBase64 = screenshotBuffer.toString('base64');
      const currentUrl = page.url();
      const functionResponses = [];
  
      for (const [name, callId, result] of results) {
          functionResponses.push({
              type: "function_result",
              name: name,
              call_id: callId,
              result: [
                  {
                      type: "text",
                      text: JSON.stringify({ url: currentUrl, ...result })
                  },
                  {
                      type: "image",
                      data: screenshotBase64,
                      mime_type: "image/png"
                  }
              ]
          });
      }
      return functionResponses;
  }
  ```

  Once you have defined how to capture and format the environment state, you can
    combine all these steps into a continuous execution loop.

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.gaos.models.interactions.FunctionResultStep;
  import com.google.genai.gaos.models.interactions.FunctionResultStepResultUnion;
  import com.google.genai.gaos.models.interactions.ImageContent;
  import com.google.genai.gaos.models.interactions.ImageContentMimeType;
  import com.google.genai.gaos.models.interactions.Step;
  import com.google.genai.gaos.models.interactions.TextContent;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Base64;
  import java.util.List;
  import java.util.Map;
  
  class StateCapturer {
    List<Step> getFunctionResponses(
        byte[] screenshotBytes, String currentUrl, List<Map<String, Object>> results) {
      List<Step> functionResponses = new ArrayList<>();
      String base64Screenshot = Base64.getEncoder().encodeToString(screenshotBytes);
  
      for (Map<String, Object> entry : results) {
        String name = (String) entry.get("name");
        String callId = (String) entry.get("callId");
        String jsonResult = String.format("{\"url\": \"%s\"}", currentUrl);
  
        FunctionResultStep responseStep =
            FunctionResultStep.builder()
                .name(name)
                .callId(callId)
                .result(
                    FunctionResultStepResultUnion.of(
                        Arrays.asList(
                            TextContent.builder().text(jsonResult).build(),
                            ImageContent.builder()
                                .data(base64Screenshot)
                                .mimeType(ImageContentMimeType.IMAGE_PNG)
                                .build())))
                .build();
        functionResponses.add(responseStep);
      }
      return functionResponses;
    }
  }
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "encoding/base64"
      "fmt"
  
      "google.golang.org/genai"
      "google.golang.org/genai/interactions/models/interactions"
  )
  
  func getFunctionResponses(screenshotBytes []byte, currentURL string, results []map[string]any) []interactions.Step {
      var functionResponses []interactions.Step
      base64Screenshot := base64.StdEncoding.EncodeToString(screenshotBytes)
  
      for _, entry := range results {
          name, _ := entry["name"].(string)
          callID, _ := entry["callId"].(string)
          jsonResult := fmt.Sprintf(`{"url": "%s"}`, currentURL)
  
          responseStep := interactions.NewStep(interactions.FunctionResultStep{
              Name:   genai.Ptr(name),
              CallID: callID,
              Result: interactions.NewFunctionResultStepResultUnion([]interactions.FunctionResultSubcontent{
                  interactions.NewFunctionResultSubcontent(interactions.TextContent{
                      Text: jsonResult,
                  }),
                  interactions.NewFunctionResultSubcontent(interactions.ImageContent{
                      Data:     genai.Ptr(base64Screenshot),
                      MimeType: interactions.ImageContentMimeType("image/png").ToPointer(),
                  }),
              }),
          })
          functionResponses = append(functionResponses, responseStep)
      }
      return functionResponses
  }
  
  func main() {
      // Example helper usage to build FunctionResultStep responses
  }
  ```

  {% /tab %}

{% /tabs %}

## Build an agent loop  {% id="agent-loop" %}

To enable multi-step interactions, combine the four steps from the [How to
implement Computer Use](/docs/computer-use#implement-computer-use) section into a single loop.
This loop continues requesting actions and feeding the results back to the model
until the task is complete.

Remember to manage the conversation history correctly by appending both the
model responses and your function responses to the history at each step.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  import time
  from typing import Any, List, Tuple
  from playwright.sync_api import sync_playwright
  
  from google import genai
  
  client = genai.Client()
  
  # Constants for screen dimensions
  SCREEN_WIDTH = 1440
  SCREEN_HEIGHT = 900
  
  # Setup Playwright
  print("Initializing browser...")
  playwright = sync_playwright().start()
  browser = playwright.chromium.launch(headless=False)
  context = browser.new_context(viewport={"width": SCREEN_WIDTH, "height": SCREEN_HEIGHT})
  page = context.new_page()
  
  # Define helper functions. Copy/paste from steps 3 and 4
  # def denormalize_x(...)
  # def denormalize_y(...)
  # def execute_function_calls(...)
  # def get_function_responses(...)
  
  try:
      # Go to initial page
      page.goto("https://ai.google.dev/gemini-api/docs")
  
      # Take initial screenshot
      initial_screenshot = page.screenshot(type="png")
      USER_PROMPT = "Go to ai.google.dev/gemini-api/docs and search for pricing."
      print(f"Goal: {USER_PROMPT}")
  
      # First interaction
      interaction = client.interactions.create(
          model='gemini-3.8-flash',
          input=[
              {"type": "text", "text": USER_PROMPT},
              {"type": "image", "data": base64.b64encode(initial_screenshot).decode("utf-8"), "mime_type": "image/png"}
          ],
          tools=[{
              "type": "computer_use",
              "environment": "browser",
              "enable_prompt_injection_detection": True
          }]
      )
  
      # Agent Loop
      turn_limit = 5
      for i in range(turn_limit):
          print(f"\n--- Turn {i+1} ---")
  
          has_function_calls = any(
              step.type == "function_call"
              for step in interaction.steps
          )
          if not has_function_calls:
              text_response = " ".join([
                  content_block.text for step in interaction.steps if step.type == "model_output"
                  for content_block in step.content if content_block.type == "text"
              ])
              print("Agent finished:", text_response)
              break
  
          print("Executing actions...")
          results = execute_function_calls(interaction, page, SCREEN_WIDTH, SCREEN_HEIGHT)
  
          print("Capturing state...")
          function_responses = get_function_responses(page, results)
  
          # Continue conversation with function responses
          interaction = client.interactions.create(
              model='gemini-3.8-flash',
              previous_interaction_id=interaction.id,
              input=function_responses,
              tools=[{
                  "type": "computer_use",
                  "environment": "browser",
                  "enable_prompt_injection_detection": True
              }]
          )
  
  finally:
      # Cleanup
      print("\nClosing browser...")
      browser.close()
      playwright.stop()
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { chromium } from 'playwright';
  import { GoogleGenAI } from '@google/genai';
  
  const ai = new GoogleGenAI();
  
  // Constants for screen dimensions
  const SCREEN_WIDTH = 1440;
  const SCREEN_HEIGHT = 900;
  
  console.log("Initializing browser...");
  const browser = await chromium.launch({ headless: false });
  const context = await browser.newContext({
      viewport: { width: SCREEN_WIDTH, height: SCREEN_HEIGHT }
  });
  const page = await context.newPage();
  
  // Define helper functions. Copy/paste from steps 3 and 4:
  // function denormalizeX(...)
  // function denormalizeY(...)
  // async function executeFunctionCalls(...)
  // async function getFunctionResponses(...)
  
  try {
      // Go to initial page
      await page.goto("https://ai.google.dev/gemini-api/docs");
  
      // Take initial screenshot
      const initialScreenshotBuffer = await page.screenshot({ type: 'png' });
      const initialScreenshotBase64 = initialScreenshotBuffer.toString('base64');
      const USER_PROMPT = "Go to ai.google.dev/gemini-api/docs and search for pricing.";
      console.log(`Goal: ${USER_PROMPT}`);
  
      // First interaction
      let interaction = await ai.interactions.create({
          model: 'gemini-3.8-flash',
          input: [
              { type: 'text', text: USER_PROMPT },
              { type: 'image', data: initialScreenshotBase64, mime_type: 'image/png' }
          ],
          tools: [{
              type: 'computer_use',
              environment: 'browser',
              enable_prompt_injection_detection: true
          }]
      });
  
      // Agent Loop
      const turnLimit = 5;
      for (let i = 0; i < turnLimit; i++) {
          console.log(`\n--- Turn ${i + 1} ---`);
  
          const hasFunctionCalls = (interaction.steps || []).some(step => step.type === "function_call");
          if (!hasFunctionCalls) {
              const textResponses = [];
              for (const step of interaction.steps || []) {
                  if (step.type === "model_output") {
                      for (const contentBlock of step.content || []) {
                          if (contentBlock.type === "text") {
                              textResponses.push(contentBlock.text);
                          }
                      }
                  }
              }
              console.log("Agent finished:", textResponses.join(" "));
              break;
          }
  
          console.log("Executing actions...");
          const results = await executeFunctionCalls(interaction, page, SCREEN_WIDTH, SCREEN_HEIGHT);
  
          console.log("Capturing state...");
          const functionResponses = await getFunctionResponses(page, results);
  
          // Continue conversation with function responses
          interaction = await ai.interactions.create({
              model: 'gemini-3.8-flash',
              previous_interaction_id: interaction.id,
              input: functionResponses,
              tools: [{
                  type: 'computer_use',
                  environment: 'browser',
                  enable_prompt_injection_detection: true
              }]
          });
      }
  } finally {
      // Cleanup
      console.log("\nClosing browser...");
      await browser.close();
  }
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.gaos.models.interactions.ComputerUse;
  import com.google.genai.gaos.models.interactions.Content;
  import com.google.genai.gaos.models.interactions.CreateModelInteraction;
  import com.google.genai.gaos.models.interactions.EnvironmentEnum;
  import com.google.genai.gaos.models.interactions.FunctionCallStep;
  import com.google.genai.gaos.models.interactions.ImageContent;
  import com.google.genai.gaos.models.interactions.ImageContentMimeType;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.interactions.ModelOutputStep;
  import com.google.genai.gaos.models.interactions.Step;
  import com.google.genai.gaos.models.interactions.TextContent;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Base64;
  import java.util.Collections;
  import java.util.List;
  
  Client client = new Client();
  
  // Constants for screen dimensions
  int screenWidth = 1440;
  int screenHeight = 900;
  
  // Capture initial screenshot from browser driver (e.g. Playwright)
  byte[] initialScreenshot = new byte[0];
  String base64Screenshot = Base64.getEncoder().encodeToString(initialScreenshot);
  String userPrompt = "Go to ai.google.dev/gemini-api/docs and search for pricing.";
  System.out.println("Goal: " + userPrompt);
  
  ComputerUse computerUseTool =
      ComputerUse.builder()
          .environment(EnvironmentEnum.BROWSER)
          .enablePromptInjectionDetection(true)
          .build();
  
  CreateModelInteraction initialParams =
      CreateModelInteraction.builder()
          .model("gemini-3.8-flash")
          .input(
              InteractionsInput.ofContent(
                  Arrays.asList(
                      TextContent.builder().text(userPrompt).build(),
                      ImageContent.builder()
                          .data(base64Screenshot)
                          .mimeType(ImageContentMimeType.IMAGE_PNG)
                          .build())))
          .tools(Arrays.asList(computerUseTool))
          .build();
  
  Interaction interaction =
      client.interactions.create(CreateInteractionRequestBody.of(initialParams)).interaction().get();
  
  int turnLimit = 5;
  for (int i = 0; i < turnLimit; i++) {
    System.out.println("\n--- Turn " + (i + 1) + " ---");
  
    boolean hasFunctionCalls =
        interaction.steps().orElse(Collections.emptyList()).stream()
            .anyMatch(step -> step instanceof FunctionCallStep);
  
    if (!hasFunctionCalls) {
      StringBuilder textResponse = new StringBuilder();
      for (Step step : interaction.steps().orElse(Collections.emptyList())) {
        if (step instanceof ModelOutputStep) {
          for (Content contentBlock :
              ((ModelOutputStep) step).content().orElse(Collections.emptyList())) {
            if (contentBlock instanceof TextContent) {
              textResponse.append(((TextContent) contentBlock).text().orElse("")).append(" ");
            }
          }
        }
      }
      System.out.println("Agent finished: " + textResponse.toString().trim());
      break;
    }
  
    System.out.println("Executing actions and capturing state...");
    // Execute function calls against browser driver and capture List<Step> functionResponses
    List<Step> functionResponses = new ArrayList<>();
  
    CreateModelInteraction nextParams =
        CreateModelInteraction.builder()
            .model("gemini-3.8-flash")
            .previousInteractionId(interaction.id().get())
            .input(InteractionsInput.ofStep(functionResponses))
            .tools(Arrays.asList(computerUseTool))
            .build();
  
    interaction =
        client.interactions.create(CreateInteractionRequestBody.of(nextParams)).interaction().get();
  }
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "encoding/base64"
      "fmt"
      "log"
      "strings"
  
      "google.golang.org/genai"
      "google.golang.org/genai/interactions/models/interactions"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      client, err := genai.NewClient(ctx, nil)
      if err != nil {
          log.Fatal(err)
      }
  
      // Constants for screen dimensions
      screenWidth := 1440
      screenHeight := 900
      _ = screenWidth
      _ = screenHeight
  
      // Capture initial screenshot from browser driver (e.g. Playwright)
      initialScreenshot := []byte{}
      base64Screenshot := base64.StdEncoding.EncodeToString(initialScreenshot)
      userPrompt := "Go to ai.google.dev/gemini-api/docs and search for pricing."
      fmt.Println("Goal:", userPrompt)
  
      computerUseTool := interactions.NewTool(interactions.ComputerUse{
          Environment:                    interactions.EnvironmentEnumBrowser.ToPointer(),
          EnablePromptInjectionDetection: genai.Ptr(true),
      })
  
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
              Model: interactions.Model("gemini-3.8-flash"),
              Input: interactions.NewInteractionsInput([]interactions.Content{
                  interactions.NewContent(interactions.TextContent{Text: userPrompt}),
                  interactions.NewContent(interactions.ImageContent{
                      Data:     genai.Ptr(base64Screenshot),
                      MimeType: interactions.ImageContentMimeType("image/png").ToPointer(),
                  }),
              }),
              Tools: []interactions.Tool{computerUseTool},
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
      interaction := res.Interaction
  
      turnLimit := 5
      for i := 0; i < turnLimit; i++ {
          fmt.Printf("\n--- Turn %d ---\n", i+1)
  
          hasFunctionCalls := false
          for _, step := range interaction.Steps {
              if step.FunctionCallStep != nil {
                  hasFunctionCalls = true
                  break
              }
          }
  
          if !hasFunctionCalls {
              var parts []string
              for _, step := range interaction.Steps {
                  if outStep := step.ModelOutputStep; outStep != nil {
                      for _, contentBlock := range outStep.Content {
                          if textContent := contentBlock.TextContent; textContent != nil {
                              parts = append(parts, textContent.GetText())
                          }
                      }
                  }
              }
              fmt.Println("Agent finished:", strings.TrimSpace(strings.Join(parts, " ")))
              break
          }
  
          fmt.Println("Executing actions and capturing state...")
          // Execute function calls against browser driver and capture []interactions.Step functionResponses
          var functionResponses []interactions.Step
  
          nextRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
              Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
                  Model:                 interactions.Model("gemini-3.8-flash"),
                  PreviousInteractionID: interaction.ID,
                  Input:                 interactions.NewInteractionsInput(functionResponses),
                  Tools:                 []interactions.Tool{computerUseTool},
              }),
          })
          if err != nil {
              log.Fatal(err)
          }
          interaction = nextRes.Interaction
      }
  }
  ```

  {% /tab %}

{% /tabs %}

## Supported environments  {% id="supported-environments" %}

Gemini 4 and Gemini 3.x models support three environments specified in the
`computer_use` configurations:

### Browser environment (`ENVIRONMENT_BROWSER`)

Available actions under browser tool:

| Command name | Description | Arguments (in function call) |
| :--- | :--- | :--- |
| **click** | Left clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **double_click** | Double clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **triple_click** | Triple clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **middle_click** | Middle clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **right_click** | Right clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **mouse_down** | Presses and holds the mouse button at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **mouse_up** | Releases the mouse button at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **move** | Moves the cursor to the specified position. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **type** | Types text. | `text`: str`press_enter`: bool (Optional, default `false`)`intent`: str |
| **drag_and_drop** | Drags an item from the start coordinate to the end coordinate. | `start_y`: int (0-999)`start_x`: int (0-999)`end_y`: int (0-999)`end_x`: int (0-999)`intent`: str |
| **wait** | Pauses execution for a specified number of seconds. | `seconds`: int (Optional, default `1`)`intent`: str |
| **press_key** | Presses the specified key and releases it. | `key`: str`intent`: str |
| **key_down** | Presses and holds the specified key. | `key`: str`intent`: str |
| **key_up** | Releases the specified key. | `key`: str`intent`: str |
| **hotkey** | Presses the specified key combination. | `keys`: `List[str]``intent`: `str` |
| **take_screenshot** | Returns a screenshot of the current screen. | `intent`: str |
| **scroll** | Scrolls up, down, left, or right at a coordinate by a pixel distance. | `y`: int (0-999)`x`: int (0-999)`direction`: str (`"up"`, `"down"`, `"left"`, `"right"`)`magnitude_in_pixels`: int (0-999, Optional, default `300`)`intent`: str |
| **go_back** | Navigates back to the previous webpage in the browser history. | `intent`: str |
| **navigate** | Navigates directly to a specified URL. | `url`: str`intent`: str |
| **go_forward** | Navigates forward to the next webpage in the browser history. | `intent`: str |

### Mobile environment (`ENVIRONMENT_MOBILE`)  {% id="mobile-environment" %}

Android-optimized environment actions:

| Command name | Description | Arguments (in function call) |
| :--- | :--- | :--- |
| **open_app** | Opens an application by its name. | `app_name`: str`intent`: str |
| **click** | Left clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **list_apps** | Lists available applications on the device, returning their names and package names. | `intent`: str |
| **wait** | Pauses execution for a specified number of seconds. | `seconds`: int (Optional, default `1`)`intent`: str |
| **go_back** | Navigates back to the previous screen or webpage. | `intent`: str |
| **type** | Types text. | `text`: str`press_enter`: bool (Optional, default `false`)`intent`: str |
| **drag_and_drop** | Drags an item from the start coordinate to the end coordinate. | `start_y`: int (0-999)`start_x`: int (0-999)`end_y`: int (0-999)`end_x`: int (0-999)`intent`: str |
| **long_press** | Performs a long press at a coordinate on the screen. | `y`: int (0-999)`x`: int (0-999)`seconds`: int (Optional, default `2`)`intent`: str |
| **press_key** | Presses the specified key and releases it. | `key`: str`intent`: str |
| **take_screenshot** | Returns a screenshot of the current screen. | `intent`: str |

### Desktop environment (`ENVIRONMENT_DESKTOP`)  {% id="desktop-environment" %}

Desktop environments OS-level cursor commands:

| Command name | Description | Arguments (in function call) |
| :--- | :--- | :--- |
| **click** | Left clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **double_click** | Double clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **triple_click** | Triple clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **middle_click** | Middle clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **right_click** | Right clicks at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **mouse_down** | Presses and holds the mouse button at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **mouse_up** | Releases the mouse button at the coordinate. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **move** | Moves the cursor to the specified position. | `y`: int (0-999)`x`: int (0-999)`intent`: str |
| **type** | Types text. | `text`: str`press_enter`: bool (Optional, default `false`)`intent`: str |
| **drag_and_drop** | Drags an item from the start coordinate to the end coordinate. | `start_y`: int (0-999)`start_x`: int (0-999)`end_y`: int (0-999)`end_x`: int (0-999)`intent`: str |
| **wait** | Pauses execution for a specified number of seconds. | `seconds`: int (Optional, default `1`)`intent`: str |
| **press_key** | Presses the specified key and releases it. | `key`: str`intent`: str |
| **key_down** | Presses and holds the specified key. | `key`: str`intent`: str |
| **key_up** | Releases the specified key. | `key`: str`intent`: str |
| **hotkey** | Presses the specified key combination. | `keys`: `List[str]``intent`: `str` |
| **take_screenshot** | Returns a screenshot of the current screen. | `intent`: str |
| **scroll** | Scrolls up, down, left, or right at a coordinate by a pixel distance. | `y`: int (0-999)`x`: int (0-999)`direction`: str (`"up"`, `"down"`, `"left"`, `"right"`)`magnitude_in_pixels`: int (0-999, Optional, default `300`)`intent`: str |

## Custom user-defined functions  {% id="custom-functions" %}

You can extend the functionality of the model by including custom user-defined functions. For example, in human-in-the-loop (HITL) scenarios you can exclude default predefined actions and register custom actions.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  Exclude standard predefined browser actions (such as `click`) and register a custom `yield_to_user` tool:

  ```python
  from google import genai
  
  client = genai.Client()
  
  yield_to_user_tool = {
      "type": "function",
      "name": "yield_to_user",
      "description": "Yields control back to the user for assistance or verification when an automated action is unsafe or ambiguous.",
      "parameters": {
          "type": "object",
          "properties": {
              "reason": {
                  "type": "string",
                  "description": "The reason why the agent is yielding control to the human."
              }
          },
          "required": ["reason"]
      }
  }
  
  interaction = client.interactions.create(
      model="gemini-3.8-flash",
      input="Click the submit button. If you need a second factor authentication code, ask me.",
      tools=[
          {
              "type": "computer_use",
              "environment": "mobile",
              "excluded_predefined_functions": ["click"]
          },
          yield_to_user_tool
      ]
  )
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  Exclude standard predefined browser actions (such as `click`) and register a custom `yield_to_user` tool:

  ```javascript
  import { GoogleGenAI } from '@google/genai';
  
  const ai = new GoogleGenAI();
  
  const interaction = await ai.interactions.create({
      model: "gemini-3.8-flash",
      input: "Click the submit button. If you need a second factor authentication code, ask me.",
      tools: [
          {
              type: "computer_use",
              environment: "mobile",
              excluded_predefined_functions: ["click"]
          },
          {
              type: "function",
              name: "yield_to_user",
              description: "Yields control back to the user for assistance or verification when an automated action is unsafe or ambiguous.",
              parameters: {
                  type: "object",
                  properties: {
                      reason: {
                          type: "string",
                          description: "The reason why the agent is yielding control to the human."
                      }
                  },
                  required: ["reason"]
              }
          }
      ]
  });
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.gaos.models.interactions.ComputerUse;
  import com.google.genai.gaos.models.interactions.CreateModelInteraction;
  import com.google.genai.gaos.models.interactions.EnvironmentEnum;
  import com.google.genai.gaos.models.interactions.Function;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  
  Client client = new Client();
  
  Map<String, Object> reasonProp = new HashMap<>();
  reasonProp.put("type", "string");
  reasonProp.put("description", "The reason why the agent is yielding control to the human.");
  
  Map<String, Object> properties = new HashMap<>();
  properties.put("reason", reasonProp);
  
  Map<String, Object> parameters = new HashMap<>();
  parameters.put("type", "object");
  parameters.put("properties", properties);
  parameters.put("required", Collections.singletonList("reason"));
  
  Function yieldToUserTool =
      Function.builder()
          .name("yield_to_user")
          .description(
              "Yields control back to the user for assistance or verification when an automated action is unsafe or ambiguous.")
          .parameters(parameters)
          .build();
  
  CreateModelInteraction params =
      CreateModelInteraction.builder()
          .model("gemini-3.8-flash")
          .input(
              InteractionsInput.of(
                  "Click the submit button. If you need a second factor authentication code, ask me."))
          .tools(
              Arrays.asList(
                  ComputerUse.builder()
                      .environment(EnvironmentEnum.MOBILE)
                      .excludedPredefinedFunctions(Arrays.asList("click"))
                      .build(),
                  yieldToUserTool))
          .build();
  
  Interaction interaction =
      client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "log"
  
      "google.golang.org/genai"
      "google.golang.org/genai/interactions/models/interactions"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      client, err := genai.NewClient(ctx, nil)
      if err != nil {
          log.Fatal(err)
      }
  
      yieldToUserTool := interactions.NewTool(interactions.Function{
          Name:        genai.Ptr("yield_to_user"),
          Description: genai.Ptr("Yields control back to the user for assistance or verification when an automated action is unsafe or ambiguous."),
          Parameters: map[string]any{
              "type": "object",
              "properties": map[string]any{
                  "reason": map[string]any{
                      "type":        "string",
                      "description": "The reason why the agent is yielding control to the human.",
                  },
              },
              "required": []string{"reason"},
          },
      })
  
      _, err = client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
              Model: interactions.Model("gemini-3.8-flash"),
              Input: interactions.NewInteractionsInput("Click the submit button. If you need a second factor authentication code, ask me."),
              Tools: []interactions.Tool{
                  interactions.NewTool(interactions.ComputerUse{
                      Environment:                 interactions.EnvironmentEnumMobile.ToPointer(),
                      ExcludedPredefinedFunctions: []string{"click"},
                  }),
                  yieldToUserTool,
              },
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

## Managing thinking levels  {% id="thinking-levels" %}

For computer use agents, you can configure different thinking levels to balance action quality and execution speed. Lower thinking levels generally achieve a good balance for standard automation tasks.

## Safety and security  {% id="safety-security" %}

### Configuring safety policies  {% id="safety-policies" %}

Gemini 4 and Gemini 3.x models include built-in safety service categories that
help to determine if user confirmation is required.

| Safety policy category | Description |
| :--- | :--- |
| `FINANCIAL_TRANSACTIONS` | Blocks or triggers confirmation for actions involving payments, retail checkout, or regulated goods. |
| `SENSITIVE_DATA_MODIFICATION` | Protects health, financial, or government records from unauthorized modification. |
| `COMMUNICATION_TOOL` | Restricts the agent from autonomously sending emails, chat messages, or drafts. |
| `ACCOUNT_CREATION` | Restricts the agent from autonomously registering new accounts on websites. |
| `DATA_MODIFICATION` | Regulates overall file system modifications, data sharing, and storage deletion. |
| `USER_CONSENT_MANAGEMENT` | Requires user takeover for cookie consent banners and privacy prompts. |
| `LEGAL_TERMS_AND_AGREEMENTS` | Prevents the model from autonomously accepting Terms of Service or legally binding contracts. |

#### Safety overrides

You can override select policies by passing overrides:

{% callout type="note" %}
  Safety overrides indicate your preference, but the model may still return
  a `safety_decision` with `require_confirmation` in some cases. Your application
  should always implement safety decision handling regardless of configured
  overrides.

{% /callout %}

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  from google import genai
  
  client = genai.Client()
  
  interaction = client.interactions.create(
      model="gemini-3.8-flash",
      input="Clean up the local folder by archiving old logs.",
      tools=[
          {
              "type": "computer_use",
              "environment": "desktop",
              "disabled_safety_policies": [
                  "data_modification"
              ]
          }
      ]
  )
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from '@google/genai';
  
  const ai = new GoogleGenAI();
  
  const interaction = await ai.interactions.create({
      model: "gemini-3.8-flash",
      input: "Clean up the local folder by archiving old logs.",
      tools: [
          {
              type: "computer_use",
              environment: "desktop",
              disabled_safety_policies: [
                  "data_modification"
              ]
          }
      ]
  });
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.gaos.models.interactions.ComputerUse;
  import com.google.genai.gaos.models.interactions.CreateModelInteraction;
  import com.google.genai.gaos.models.interactions.DisabledSafetyPolicy;
  import com.google.genai.gaos.models.interactions.EnvironmentEnum;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.Arrays;
  
  Client client = new Client();
  
  CreateModelInteraction params =
      CreateModelInteraction.builder()
          .model("gemini-3.8-flash")
          .input(InteractionsInput.of("Clean up the local folder by archiving old logs."))
          .tools(
              Arrays.asList(
                  ComputerUse.builder()
                      .environment(EnvironmentEnum.DESKTOP)
                      .disabledSafetyPolicies(
                          Arrays.asList(DisabledSafetyPolicy.DATA_MODIFICATION))
                      .build()))
          .build();
  
  Interaction interaction =
      client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "log"
  
      "google.golang.org/genai"
      "google.golang.org/genai/interactions/models/interactions"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      client, err := genai.NewClient(ctx, nil)
      if err != nil {
          log.Fatal(err)
      }
  
      _, err = client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
              Model: interactions.Model("gemini-3.8-flash"),
              Input: interactions.NewInteractionsInput("Clean up the local folder by archiving old logs."),
              Tools: []interactions.Tool{
                  interactions.NewTool(interactions.ComputerUse{
                      Environment: interactions.EnvironmentEnumDesktop.ToPointer(),
                      DisabledSafetyPolicies: []interactions.DisabledSafetyPolicy{
                          interactions.DisabledSafetyPolicyDataModification,
                      },
                  }),
              },
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

### Prompt injection detection  {% id="prompt-injection" %}

Computer Use for Gemini 3.5 Flash-Lite or later supports an advanced safety
mechanism to detect prompt injection attacks. When enabled, this feature checks
whether an included screenshot contains hidden adversarial instructions (for
example, "Ignore previous commands") and blocks execution when detected.

Prompt injection detection is an opt-in feature. The default is `false`.

The following examples demonstrate how to enable prompt injection detection
in your Computer Use tool configuration:

{% tabs %}
  {% tab label="Python" %}
  ```python
  from google import genai
  
  client = genai.Client()
  
  interaction = client.interactions.create(
      model="gemini-3.8-flash",
      input="Search for flight deals and summarize top results.",
      tools=[
          {
              "type": "computer_use",
              "environment": "desktop",
              "enable_prompt_injection_detection": True,
          }
      ],
  )
  ```

  {% /tab %}

  {% tab label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from '@google/genai';
  
  const ai = new GoogleGenAI();
  
  const interaction = await ai.interactions.create({
      model: "gemini-3.8-flash",
      input: "Search for flight deals and summarize top results.",
      tools: [
          {
              type: "computer_use",
              environment: "desktop",
              enable_prompt_injection_detection: true,
          }
      ]
  });
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.gaos.models.interactions.ComputerUse;
  import com.google.genai.gaos.models.interactions.CreateModelInteraction;
  import com.google.genai.gaos.models.interactions.EnvironmentEnum;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.Arrays;
  
  Client client = new Client();
  
  CreateModelInteraction params =
      CreateModelInteraction.builder()
          .model("gemini-3.8-flash")
          .input(InteractionsInput.of("Search for flight deals and summarize top results."))
          .tools(
              Arrays.asList(
                  ComputerUse.builder()
                      .environment(EnvironmentEnum.DESKTOP)
                      .enablePromptInjectionDetection(true)
                      .build()))
          .build();
  
  Interaction interaction =
      client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "log"
  
      "google.golang.org/genai"
      "google.golang.org/genai/interactions/models/interactions"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      client, err := genai.NewClient(ctx, nil)
      if err != nil {
          log.Fatal(err)
      }
  
      _, err = client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
              Model: interactions.Model("gemini-3.8-flash"),
              Input: interactions.NewInteractionsInput("Search for flight deals and summarize top results."),
              Tools: []interactions.Tool{
                  interactions.NewTool(interactions.ComputerUse{
                      Environment:                    interactions.EnvironmentEnumDesktop.ToPointer(),
                      EnablePromptInjectionDetection: genai.Ptr(true),
                  }),
              },
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  }
  ```

  {% /tab %}

  {% tab label="cURL" %}
  ```bash
  curl "https://generativelanguage.googleapis.com/v1/interactions?key=${GEMINI_API_KEY}" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3.8-flash",
    "input": "Search for flight deals and summarize top results.",
    "tools": [
      {
        "type": "computer_use",
        "environment": "desktop",
        "enable_prompt_injection_detection": true
      }
    ]
  }'
  ```

  {% /tab %}

{% /tabs %}

### Acknowledge safety decision  {% id="safety-decisions" %}

The response may include a `safety_decision` parameter in the function call arguments:

```json
{
  "steps": [
    {
      "type": "function_call",
      "name": "click",
      "arguments": {
        "x": 60,
        "y": 100,
        "safety_decision": {
          "explanation": "Must check check-box",
          "decision": "require_confirmation"
        }
      }
    }
  ]
}
```

If the `safety_decision` is `require_confirmation`, prompt the end user. If the user confirms, set `safety_acknowledgement` in `function_result`.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  def get_safety_confirmation(safety_decision):
      # Prompt user for confirmation
      print(f"Safety confirmation required: {safety_decision.get('explanation', '')}")
      return "CONTINUE" # Or TERMINATE
  
  # Inside execute_function_calls, check for safety_decision:
  if 'safety_decision' in function_call.arguments:
      decision = get_safety_confirmation(function_call.arguments['safety_decision'])
      if decision == "TERMINATE":
          break
      # Include safety_acknowledgement inside the action result
      action_result["safety_acknowledgement"] = True
  ```

  {% /tab %}

{% /tabs %}

### Safety best practices  {% id="safety-best-practices" %}

Computer Use presents unique security and operational risks, as a model acting
on a user's behalf might encounter untrusted content on screens or make errors
in executing actions. Implement the following best practices to protect user
data and systems:

1. **Human-in-the-Loop (HITL):**  *  **Enforce user confirmation:** When the safety response indicates
    `require_confirmation`, prompt the user for approval.
  *  **Provide custom safety instructions:** Implement a custom system instruction to define and enforce your own safety boundaries. For example:


{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
              from google import genai
  
              client = genai.Client()
  
              system_instruction = """
              ## **RULE 1: Seek User Confirmation (USER_CONFIRMATION)**
  
              This is your first and most important check. If the next required action falls
              into any of the following categories, you MUST stop immediately, and seek the
              user's explicit permission.
  
              **Procedure for Seeking Confirmation:**
              * **For Consequential Actions:** Perform all preparatory steps (e.g., navigating,
                filling out forms, typing a message). You will ask for confirmation **AFTER**
                all necessary information is entered on the screen, but **BEFORE** you perform
                the final, irreversible action (e.g., before clicking "Send", "Submit",
                "Confirm Purchase", "Share").
              * **For Prohibited Actions:** If the action is strictly forbidden (e.g., accepting
                legal terms, solving a CAPTCHA), you must first inform the user about the
                required action and ask for their confirmation to proceed.
  
              **USER_CONFIRMATION Categories:**
  
              *   **Consent and Agreements:** You are FORBIDDEN from accepting, selecting, or
                  agreeing to any of the following on the user's behalf. You must ask the
                  user to confirm before performing these actions.
                  *   Terms of Service
                  *   Privacy Policies
                  *   Cookie consent banners
                  *   End User License Agreements (EULAs)
                  *   Any other legally significant contracts or agreements.
              *   **Robot Detection:** You MUST NEVER attempt to solve or bypass the
                  following. You must ask the user to confirm before performing these actions.
                  *   CAPTCHAs (of any kind)
                  *   Any other anti-robot or human-verification mechanisms, even if you are
                      capable.
              *   **Financial Transactions:**
                  *   Completing any purchase.
                  *   Managing or moving money (e.g., transfers, payments).
                  *   Purchasing regulated goods or participating in gambling.
              *   **Sending Communications:**
                  *   Sending emails.
                  *   Sending messages on any platform (e.g., social media, chat apps).
                  *   Posting content on social media or forums.
              *   **Accessing or Modifying Sensitive Information:**
                  *   Health, financial, or government records (e.g., medical history, tax
                      forms, passport status).
                  *   Revealing or modifying sensitive personal identifiers (e.g., SSN, bank
                      account number, credit card number).
              *   **User Data Management:**
                  *   Accessing, downloading, or saving files from the web.
                  *   Sharing or sending files/data to any third party.
                  *   Transferring user data between systems.
              *   **Browser Data Usage:**
                  *   Accessing or managing Chrome browsing history, bookmarks, autofill data,
                      or saved passwords.
              *   **Security and Identity:**
                  *   Logging into any user account.
                  *   Any action that involves misrepresentation or impersonation (e.g.,
                      creating a fan account, posting as someone else).
              *   **Insurmountable Obstacles:** If you are technically unable to interact with
                  a user interface element or are stuck in a loop you cannot resolve, ask the
                  user to take over.
              ---
  
              ## **RULE 2: Default Behavior (ACTUATE)**
  
              If an action does **NOT** fall under the conditions for `USER_CONFIRMATION`,
              your default behavior is to **Actuate**.
  
              **Actuation Means:**  You MUST proactively perform all necessary steps to move
              the user's request forward. Continue to actuate until you either complete the
              non-consequential task or encounter a condition defined in Rule 1.
  
              *   **Example 1:** If asked to send money, you will navigate to the payment
                  portal, enter the recipient's details, and enter the amount. You will then
                  **STOP** as per Rule 1 and ask for confirmation before clicking the final
                  "Send" button.
              *   **Example 2:** If asked to post a message, you will navigate to the site,
                  open the post composition window, and write the full message. You will then
                  **STOP** as per Rule 1 and ask for confirmation before clicking the final
                  "Post" button.
  
                  After the user has confirmed, remember to get the user's latest screen
                  before continuing to perform actions.
  
              # Final Response Guidelines:
              Write final response to the user in the following cases:
              - User confirmation
              - When the task is complete or you have enough information to respond to the user
              """
  
              interaction = client.interactions.create(
                  model="gemini-3.8-flash",
                  system_instruction=system_instruction,
                  input="Prepare a draft but do not send.",
                  tools=[{
                      "type": "computer_use",
                      "environment": "browser"
                  }]
              )
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
              import { GoogleGenAI } from '@google/genai';
  
              const ai = new GoogleGenAI();
  
              const systemInstruction = `
              ## **RULE 1: Seek User Confirmation (USER_CONFIRMATION)**
  
              This is your first and most important check. If the next required action falls
              into any of the following categories, you MUST stop immediately, and seek the
              user's explicit permission.
  
              **Procedure for Seeking Confirmation:**
              * **For Consequential Actions:** Perform all preparatory steps (e.g., navigating,
                filling out forms, typing a message). You will ask for confirmation **AFTER**
                all necessary information is entered on the screen, but **BEFORE** you perform
                the final, irreversible action (e.g., before clicking "Send", "Submit",
                "Confirm Purchase", "Share").
              * **For Prohibited Actions:** If the action is strictly forbidden (e.g., accepting
                legal terms, solving a CAPTCHA), you must first inform the user about the
                required action and ask for their confirmation to proceed.
  
              **USER_CONFIRMATION Categories:**
  
              *   **Consent and Agreements:** You are FORBIDDEN from accepting, selecting, or
                  agreeing to any of the following on the user's behalf. You must ask the
                  user to confirm before performing these actions.
                  *   Terms of Service
                  *   Privacy Policies
                  *   Cookie consent banners
                  *   End User License Agreements (EULAs)
                  *   Any other legally significant contracts or agreements.
              *   **Robot Detection:** You MUST NEVER attempt to solve or bypass the
                  following. You must ask the user to confirm before performing these actions.
                  *   CAPTCHAs (of any kind)
                  *   Any other anti-robot or human-verification mechanisms, even if you are
                      capable.
              *   **Financial Transactions:**
                  *   Completing any purchase.
                  *   Managing or moving money (e.g., transfers, payments).
                  *   Purchasing regulated goods or participating in gambling.
              *   **Sending Communications:**
                  *   Sending emails.
                  *   Sending messages on any platform (e.g., social media, chat apps).
                  *   Posting content on social media or forums.
              *   **Accessing or Modifying Sensitive Information:**
                  *   Health, financial, or government records (e.g., medical history, tax
                      forms, passport status).
                  *   Revealing or modifying sensitive personal identifiers (e.g., SSN, bank
                      account number, credit card number).
              *   **User Data Management:**
                  *   Accessing, downloading, or saving files from the web.
                  *   Sharing or sending files/data to any third party.
                  *   Transferring user data between systems.
              *   **Browser Data Usage:**
                  *   Accessing or managing Chrome browsing history, bookmarks, autofill data,
                      or saved passwords.
              *   **Security and Identity:**
                  *   Logging into any user account.
                  *   Any action that involves misrepresentation or impersonation (e.g.,
                      creating a fan account, posting as someone else).
              *   **Insurmountable Obstacles:** If you are technically unable to interact with
                  a user interface element or are stuck in a loop you cannot resolve, ask the
                  user to take over.
              ---
  
              ## **RULE 2: Default Behavior (ACTUATE)**
  
              If an action does **NOT** fall under the conditions for \`USER_CONFIRMATION\`,
              your default behavior is to **Actuate**.
  
              **Actuation Means:**  You MUST proactively perform all necessary steps to move
              the user's request forward. Continue to actuate until you either complete the
              non-consequential task or encounter a condition defined in Rule 1.
  
              *   **Example 1:** If asked to send money, you will navigate to the payment
                  portal, enter the recipient's details, and enter the amount. You will then
                  **STOP** as per Rule 1 and ask for confirmation before clicking the final
                  "Send" button.
              *   **Example 2:** If asked to post a message, you will navigate to the site,
                  open the post composition window, and write the full message. You will then
                  **STOP** as per Rule 1 and ask for confirmation before clicking the final
                  "Post" button.
  
                  After the user has confirmed, remember to get the user's latest screen
                  before continuing to perform actions.
  
              # Final Response Guidelines:
              Write final response to the user in the following cases:
              - User confirmation
              - When the task is complete or you have enough information to respond to the user
              `;
  
              const interaction = await ai.interactions.create({
                  model: "gemini-3.8-flash",
                  system_instruction: systemInstruction,
                  input: "Prepare a draft but do not send.",
                  tools: [{
                      type: "computer_use",
                      environment: "browser"
                  }]
              });
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.gaos.models.interactions.ComputerUse;
  import com.google.genai.gaos.models.interactions.CreateModelInteraction;
  import com.google.genai.gaos.models.interactions.EnvironmentEnum;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.Arrays;
  
  Client client = new Client();
  
  String systemInstruction =
      "## **RULE 1: Seek User Confirmation (USER_CONFIRMATION)**\n\n"
          + "This is your first and most important check. If the next required action falls "
          + "into any of the following categories, you MUST stop immediately, and seek the "
          + "user's explicit permission.\n\n"
          + "## **RULE 2: Default Behavior (ACTUATE)**\n\n"
          + "If an action does **NOT** fall under the conditions for `USER_CONFIRMATION`, "
          + "your default behavior is to **Actuate**.";
  
  CreateModelInteraction params =
      CreateModelInteraction.builder()
          .model("gemini-3.8-flash")
          .systemInstruction(systemInstruction)
          .input(InteractionsInput.of("Prepare a draft but do not send."))
          .tools(
              Arrays.asList(
                  ComputerUse.builder().environment(EnvironmentEnum.BROWSER).build()))
          .build();
  
  Interaction interaction =
      client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "log"
  
      "google.golang.org/genai"
      "google.golang.org/genai/interactions/models/interactions"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      client, err := genai.NewClient(ctx, nil)
      if err != nil {
          log.Fatal(err)
      }
  
      systemInstruction := "## **RULE 1: Seek User Confirmation (USER_CONFIRMATION)**\n\n" +
          "This is your first and most important check. If the next required action falls " +
          "into any of the following categories, you MUST stop immediately, and seek the " +
          "user's explicit permission.\n\n" +
          "## **RULE 2: Default Behavior (ACTUATE)**\n\n" +
          "If an action does **NOT** fall under the conditions for `USER_CONFIRMATION`, " +
          "your default behavior is to **Actuate**."
  
      _, err = client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
              Model:             interactions.Model("gemini-3.8-flash"),
              SystemInstruction: genai.Ptr(systemInstruction),
              Input:             interactions.NewInteractionsInput("Prepare a draft but do not send."),
              Tools: []interactions.Tool{
                  interactions.NewTool(interactions.ComputerUse{
                      Environment: interactions.EnvironmentEnumBrowser.ToPointer(),
                  }),
              },
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

1. **Secure execution environment:** Run your agent in a secure, sandboxed
  environment to limit its potential impact. This can be a sandboxed virtual
  machine (VM), a container (e.g., Docker), or a dedicated browser profile
  with limited permissions. See the
  [GitHub reference implementation](https://github.com/google/computer-use-preview/)
  for sandbox setup guidance using Docker.
2. **Input sanitization:** Sanitize all user-generated text in prompts to
  mitigate the risk of unintended instructions or prompt injection. This is a
  helpful layer of security, but not a replacement for a secure execution
  environment.
3. **Content guardrails:** Use guardrails and content safety APIs to evaluate
  user inputs, tool inputs and outputs, and the agent's responses for appropriateness,
  prompt injection, and jailbreak detection.
4. **Allowlists and blocklists:** Implement filtering mechanisms to control
  where the model can navigate and what it can do. A blocklist of prohibited
  websites is a good starting point, while a more restrictive allowlist is
  even more secure.
5. **Observability and logging:** Maintain detailed logs for debugging,
  auditing, and incident response. Your client should log prompts,
  screenshots, model-suggested actions (`function_call`), safety responses, and
  all actions ultimately executed by the client.
6. **Environment management:** Ensure the GUI environment is consistent.
  Unexpected pop-ups, notifications, or changes in layout can confuse the
  model. Start from a known, clean state for each new task if possible.

## Model versions  {% id="model-versions" %}

You can use Computer Use with the following models:

* [**Gemini 4 Argon**](/docs/models/gemini-4-argon) (`gemini-4-argon`): Our most capable model, supporting computer use for complex reasoning and agentic UI workflows.
* [**Gemini 3.8 Flash**](/docs/models/gemini-3.8-flash) (`gemini-3.8-flash`): The recommended model for
  computer use, featuring high-accuracy UI interaction and reliable tool calling.
* [**Gemini 3.5 Flash-Lite**](/docs/models/gemini-3.5-flash-lite) (`gemini-3.5-flash-lite`): A low-latency, cost-effective model supporting
  computer use.
* [**Gemini 3 Flash Preview**](/docs/models/gemini-3-flash-preview) (`gemini-3-flash-preview`): Preview model
  supporting computer use.

## What's next  {% id="whats-next" %}

* Experiment with Computer Use in the [Browserbase demo environment](http://gemini.browserbase.com).
* Check out the [Reference implementation](https://github.com/google/computer-use-preview) for example code.
* Learn about other Gemini API tools:  *   [Function calling](/docs/function-calling)
  *   [Grounding with Google Search](/docs/google-search)