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

# Antigravity agent

The Antigravity agent is a general-purpose managed agent on the Gemini API. A single API call gives you an agent that reasons, executes code, manages files, and browses the web inside your own secure Linux sandbox, hosted by Google.

It is built with Gemini 4 Hydrogen and uses the same harness as the Antigravity IDE. You can configure the underlying Gemini model using `agent_config`. Available through the [Interactions API](/docs/interactions-overview) and [Google AI Studio](https://aistudio.google.com).

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```py
  from google import genai
  
  client = genai.Client(http_options={"api_version": "v1beta"})
  
  interaction = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input="Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
      environment="remote",
  )
  
  print(interaction.output_text)
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from "@google/genai";
  
  const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
  
  const interaction = await client.interactions.create({
      agent: "antigravity-preview-09-2026",
      input: "Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
      environment: "remote",
  }, { timeout: 300000 });
  
  console.log(interaction.output_text);
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -d '{
      "agent": "antigravity-preview-09-2026",
      "input": "Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
      "environment": "remote"
  }'
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  
  CreateAgentInteraction params = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("Read Hacker News, summarize the top 10 stories, and save the results as a PDF."))
      .environment(CreateAgentInteractionEnvironment.of("remote"))
      .build();
  
  Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  System.out.println(interaction.outputText().orElse(""));
  ```

  {% /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, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent:       interactions.AgentOption("antigravity-preview-09-2026"),
              Input:       interactions.NewInteractionsInput("Read Hacker News, summarize the top 10 stories, and save the results as a PDF."),
              Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
      if res.Interaction.OutputText != nil {
          fmt.Println(*res.Interaction.OutputText)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

## Capabilities  {% id="capabilities" %}

Each call can provision a Linux sandbox and starts a tool-use loop. The agent plans, acts, observes results, and repeats until the task is done.

- **Code execution:** Run Bash, Python, and Node.js commands. Install packages, run tests, build apps.
- **File management:** Read, write, edit, search, and list files in the sandbox. Files persist across interactions.
- **Web access:** Google Search and URL fetching for data.
- **Context compaction:** Automatic context compaction (triggered at ~135k tokens) to support long-running, multi-turn sessions without losing context or hitting token limits.

See the [Quickstart](/docs/managed-agents-quickstart) for multi-turn usage and streaming.

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

By default, the agent has access to `code_execution`, `google_search`, and `url_context`. Filesystem tools are enabled automatically when you specify the `environment` parameter. You can also define **custom functions** to connect the agent to your own APIs and tools. You only need to specify the `tools` parameter when customizing or restricting the default set, or when adding custom functions.

| Tool | Type value | Description |
| :--- | :--- | :--- |
| Code Execution | `code_execution` | Run shell commands (bash, Python, Node) with stdout/stderr capture. |
| Google Search | `google_search` | Search the public web. |
| URL Context | `url_context` | Fetch and read web pages. |
| Filesystem | *(enabled via `environment`)* | Read, write, edit, search, and list files in the sandbox. The system enables these tools automatically when you set the `environment`. |
| Custom Functions | `function` | Define custom functions that the agent can request to execute. See [Function calling](/docs/antigravity-agent#function-calling). |
| Remote MCP Server | `mcp_server` | Register external Model Context Protocol (MCP) servers as tools. See [MCP servers](/docs/antigravity-agent#mcp-servers). |

You can intercept and validate `code_execution` and `filesystem` tool execution right inside the remote sandbox using synchronous [Hooks](/docs/agent-hooks).

To limit the agent to specific tools, pass only the ones you need:

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```py
  from google import genai
  
  client = genai.Client(http_options={"api_version": "v1beta"})
  
  interaction = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input="Search for the latest AI research papers on reasoning and summarize them.",
      environment="remote",
      tools=[
          {"type": "google_search"},
          {"type": "url_context"},
      ],
  )
  
  print(interaction.output_text)
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from "@google/genai";
  
  const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
  
  const interaction = await client.interactions.create({
      agent: "antigravity-preview-09-2026",
      input: "Search for the latest AI research papers on reasoning and summarize them.",
      environment: "remote",
      tools: [
          { type: "google_search" },
          { type: "url_context" },
      ],
  }, { timeout: 300000 });
  
  console.log(interaction.output_text);
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -d '{
      "agent": "antigravity-preview-09-2026",
      "input": "Search for the latest AI research papers on reasoning and summarize them.",
      "environment": "remote",
      "tools": [
          {"type": "google_search"},
          {"type": "url_context"}
      ]
  }'
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  import com.google.genai.gaos.models.interactions.GoogleSearch;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.interactions.URLContext;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.List;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  
  CreateAgentInteraction params = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("Search for the latest AI research papers on reasoning and summarize them."))
      .environment(CreateAgentInteractionEnvironment.of("remote"))
      .tools(List.of(
          GoogleSearch.builder().build(),
          URLContext.builder().build()
      ))
      .build();
  
  Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  System.out.println(interaction.outputText().orElse(""));
  ```

  {% /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, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent:       interactions.AgentOption("antigravity-preview-09-2026"),
              Input:       interactions.NewInteractionsInput("Search for the latest AI research papers on reasoning and summarize them."),
              Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
              Tools: []interactions.Tool{
                  interactions.NewTool(interactions.GoogleSearch{}),
                  interactions.NewTool(interactions.URLContext{}),
              },
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
      if res.Interaction.OutputText != nil {
          fmt.Println(*res.Interaction.OutputText)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

## Multimodal Input  {% id="multimodal-input" %}

The Antigravity agent supports multimodal inputs. Currently, only `text` and `image` inputs are supported. Images must be supplied as inline base64-encoded strings (`data`).

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```py
  import base64
  from google import genai
  
  client = genai.Client(http_options={"api_version": "v1beta"})
  
  with open("path/to/chart.png", "rb") as f:
      image_bytes = f.read()
  
  interaction_inline = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input=[
          {"type": "text", "text": "Analyze this chart and summarize the trends."},
          {
              "type": "image",
              "data": base64.b64encode(image_bytes).decode("utf-8"),
              "mime_type": "image/png",
          },
      ],
      environment="remote",
  )
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  
  import { GoogleGenAI } from "@google/genai";
  
  import * as fs from "node:fs";
  
  const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
  const base64Image = fs.readFileSync("path/to/chart.png", { encoding: "base64" });
  
  const interactionInline = await client.interactions.create({
      agent: "antigravity-preview-09-2026",
      input: [
          { type: "text", text: "Analyze this chart and summarize the trends." },
          {
              type: "image",
              data: base64Image,
              mime_type: "image/png",
          },
      ],
      environment: "remote",
  }, { timeout: 300000 });
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  BASE64_IMAGE=$(base64 -w0 /path/to/chart.png)
  
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -d "{
      \"agent\": \"antigravity-preview-09-2026\",
      \"input\": [
          {\"type\": \"text\", \"text\": \"Analyze this chart and summarize the trends.\"},
          {
              \"type\": \"image\",
              \"mime_type\": \"image/png\",
              \"data\": \"$BASE64_IMAGE\"
          }
      ],
      \"environment\": \"remote\"
  }"
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  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.TextContent;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.util.Base64;
  import java.util.List;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  
  byte[] imageBytes = Files.readAllBytes(Paths.get("path/to/chart.png"));
  String base64Image = Base64.getEncoder().encodeToString(imageBytes);
  
  CreateAgentInteraction params = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.ofContent(List.of(
          TextContent.builder().text("Analyze this chart and summarize the trends.").build(),
          ImageContent.builder()
              .data(base64Image)
              .mimeType(ImageContentMimeType.IMAGE_PNG)
              .build()
      )))
      .environment(CreateAgentInteractionEnvironment.of("remote"))
      .build();
  
  Interaction interactionInline = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  System.out.println(interactionInline.outputText().orElse(""));
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "encoding/base64"
      "fmt"
      "log"
      "os"
  
      "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, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      imageBytes, err := os.ReadFile("path/to/chart.png")
      if err != nil {
          log.Fatal(err)
      }
      base64Image := base64.StdEncoding.EncodeToString(imageBytes)
  
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent: interactions.AgentOption("antigravity-preview-09-2026"),
              Input: interactions.NewInteractionsInput([]interactions.Content{
                  interactions.NewContent(interactions.TextContent{
                      Text: "Analyze this chart and summarize the trends.",
                  }),
                  interactions.NewContent(interactions.ImageContent{
                      Data:     genai.Ptr(base64Image),
                      MimeType: interactions.ImageContentMimeTypeImagePng.ToPointer(),
                  }),
              }),
              Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
      if res.Interaction.OutputText != nil {
          fmt.Println(*res.Interaction.OutputText)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

## Function calling  {% id="function-calling" %}

Function calling allows you to connect the Antigravity agent to external APIs and databases by defining custom tools the agent can invoke. For general concepts, see [Function calling with the Gemini API](/docs/function-calling).

The following example demonstrates a 2-turn interaction. The agent first requests a custom `get_weather` function call, and the client executes it and returns the result in the second turn.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  from google import genai
  
  client = genai.Client(http_options={"api_version": "v1beta"})
  
  # 1. Define the custom function
  get_weather_tool = {
      "type": "function",
      "name": "get_weather",
      "description": "Gets the current weather for a given location.",
      "parameters": {
          "type": "object",
          "properties": {
              "location": {
                  "type": "string",
                  "description": "The city and country, e.g. San Francisco, USA",
              }
          },
          "required": ["location"],
      },
  }
  
  # 2. Call the agent with the custom tool (Turn 1)
  interaction = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input="What is the weather in Tokyo?",
      environment="remote",
      tools=[
          {"type": "code_execution"},  # Enable default code execution
          get_weather_tool,            # Add custom function
      ],
  )
  
  # Check if the agent requested a function call
  if interaction.status == "requires_action":
      # Find function calls that do not have a matching function result.
      # Filesystem tools (like write_to_file) are also represented as function calls
      # but are executed automatically by the environment.
      executed_calls = {step.call_id for step in interaction.steps if step.type == "function_result"}
      pending_calls = [step for step in interaction.steps if step.type == "function_call" and step.id not in executed_calls]
  
      if pending_calls:
          fc_step = pending_calls[0]
          print(f"Function to call: {fc_step.name} (ID: {fc_step.id})")
          print(f"Arguments: {fc_step.arguments}")
  
          # 3. Execute the function locally (simulated get_weather()) and send the result back (Turn 2)
          function_result = {
              "temperature": 23,
              "unit": "celsius"
          }
  
          final_interaction = client.interactions.create(
              agent="antigravity-preview-09-2026",
              previous_interaction_id=interaction.id,  # Reference the interaction ID
              environment=interaction.environment_id,
              input=[
                  {
                      "type": "function_result",
                      "name": fc_step.name,
                      "call_id": fc_step.id,
                      "result": function_result,
                  }
              ],
          )
  
          print(final_interaction.output_text)
          # Output: The current weather in Tokyo, Japan is 23°C (Celsius).
      else:
          print("No pending function calls.")
  else:
      print(f"Interaction completed with status: {interaction.status}")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from "@google/genai";
  
  const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
  
  // 1. Call the agent with the custom tool (Turn 1)
  const interaction = await client.interactions.create({
    agent: "antigravity-preview-09-2026",
    input: "What is the weather in Tokyo?",
    environment: "remote",
    tools: [
      { type: "code_execution" },
      {
        type: "function",
        name: "get_weather",
        description: "Gets the current weather for a given location.",
        parameters: {
          type: "object",
          properties: {
            location: {
              type: "string",
              description: "The city and country, e.g. San Francisco, USA",
            },
          },
          required: ["location"],
        },
      },
    ],
  }, { timeout: 300000 });
  
  if (interaction.status === "requires_action") {
    // Find function calls that do not have a matching function result.
    // Filesystem tools (like write_to_file) are also represented as function calls
    // but are executed automatically by the environment.
    const executedCalls = new Set(
      (interaction.steps || [])
        .filter(s => s.type === "function_result")
        .map(s => s.call_id)
    );
    const pendingCalls = (interaction.steps || []).filter(
      s => s.type === "function_call" && !executedCalls.has(s.id)
    );
  
    if (pendingCalls.length > 0) {
      const fcStep = pendingCalls[0];
      if (fcStep.type === "function_call") {
        console.log(`Function to call: ${fcStep.name} (ID: ${fcStep.id})`);
  
        // Execute the function locally (simulated get_weather()) and send the result back (Turn 2)
        const functionResult = {
          temperature: 23,
          unit: "celsius"
        };
  
        const finalInteraction = await client.interactions.create({
          agent: "antigravity-preview-09-2026",
          previous_interaction_id: interaction.id, // Reference the interaction ID
          environment: interaction.environment_id,
          input: [
            {
              type: "function_result",
              name: fcStep.name,
              call_id: fcStep.id,
              result: functionResult,
            }
          ],
        }, { timeout: 300000 });
  
        console.log(finalInteraction.output_text);
      }
    } else {
      console.log("No pending function calls.");
    }
  } else {
    console.log(`Interaction completed with status: ${interaction.status}`);
  }
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  # 1. Turn 1: Request function call
  RESPONSE=$(curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
        "agent": "antigravity-preview-09-2026",
        "input": "What is the weather in Tokyo?",
        "environment": "remote",
        "tools": [
            {"type": "code_execution"},
            {
                "type": "function",
                "name": "get_weather",
                "description": "Gets the current weather for a given location.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {"type": "string"}
                    },
                    "required": ["location"]
                }
            }
        ]
    }')
  
  # Extract interaction ID, environment ID, and call ID (requires jq)
  INTERACTION_ID=$(echo $RESPONSE | jq -r '.id')
  ENVIRONMENT_ID=$(echo $RESPONSE | jq -r '.environment_id')
  CALL_ID=$(echo $RESPONSE | jq -r '.steps[] | select(.type=="function_call") | .id')
  
  # 2. Turn 2: Send function result back using variables
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d "{
        \"agent\": \"antigravity-preview-09-2026\",
        \"previous_interaction_id\": \"$INTERACTION_ID\",
        \"environment\": \"$ENVIRONMENT_ID\",
        \"input\": [
            {
                \"type\": \"function_result\",
                \"name\": \"get_weather\",
                \"call_id\": \"$CALL_ID\",
                \"result\": {
                    \"temperature\": 23,
                    \"unit\": \"celsius\"
                }
            }
        ]
    }"
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.CodeExecution;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  import com.google.genai.gaos.models.interactions.Function;
  import com.google.genai.gaos.models.interactions.FunctionCallStep;
  import com.google.genai.gaos.models.interactions.FunctionResultStep;
  import com.google.genai.gaos.models.interactions.FunctionResultStepResultUnion;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionStatus;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.interactions.Step;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.stream.Collectors;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  
  // 1. Define the custom function
  Function getWeatherTool = Function.builder()
      .name("get_weather")
      .description("Gets the current weather for a given location.")
      .parameters(Map.of(
          "type", "object",
          "properties", Map.of(
              "location", Map.of(
                  "type", "string",
                  "description", "The city and country, e.g. San Francisco, USA"
              )
          ),
          "required", List.of("location")
      ))
      .build();
  
  // 2. Call the agent with the custom tool (Turn 1)
  CreateAgentInteraction params = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("What is the weather in Tokyo?"))
      .environment(CreateAgentInteractionEnvironment.of("remote"))
      .tools(List.of(
          CodeExecution.builder().build(), // Enable default code execution
          getWeatherTool                   // Add custom function
      ))
      .build();
  
  Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  
  // Check if the agent requested a function call
  if (interaction.status().orElse(null) == InteractionStatus.REQUIRES_ACTION) {
      // Find function calls that do not have a matching function result.
      List<Step> steps = interaction.steps().orElse(List.of());
      Set<String> executedCalls = steps.stream()
          .filter(step -> step instanceof FunctionResultStep)
          .map(step -> ((FunctionResultStep) step).callId().orElse(""))
          .collect(Collectors.toSet());
  
      List<FunctionCallStep> pendingCalls = steps.stream()
          .filter(step -> step instanceof FunctionCallStep)
          .map(step -> (FunctionCallStep) step)
          .filter(fc -> !executedCalls.contains(fc.id().orElse("")))
          .collect(Collectors.toList());
  
      if (!pendingCalls.isEmpty()) {
          FunctionCallStep fcStep = pendingCalls.get(0);
          System.out.println("Function to call: " + fcStep.name().orElse("") + " (ID: " + fcStep.id().orElse("") + ")");
          System.out.println("Arguments: " + fcStep.arguments().orElse(Map.of()));
  
          // 3. Execute the function locally (simulated get_weather()) and send the result back (Turn 2)
          FunctionResultStep resultStep = FunctionResultStep.builder()
              .name(fcStep.name().orElse(""))
              .callId(fcStep.id().orElse(""))
              .result(FunctionResultStepResultUnion.of("{\"temperature\": 23, \"unit\": \"celsius\"}"))
              .build();
  
          CreateAgentInteraction followupParams = CreateAgentInteraction.builder()
              .agent(AgentOption.of("antigravity-preview-09-2026"))
              .previousInteractionId(interaction.id().orElse(""))
              .environment(CreateAgentInteractionEnvironment.of(interaction.environmentId().orElse("")))
              .input(InteractionsInput.ofStep(List.of(resultStep)))
              .build();
  
          Interaction finalInteraction = client.interactions.create(CreateInteractionRequestBody.of(followupParams)).interaction().get();
          System.out.println(finalInteraction.outputText().orElse(""));
          // Output: The current weather in Tokyo, Japan is 23°C (Celsius).
      } else {
          System.out.println("No pending function calls.");
      }
  } else {
      System.out.println("Interaction completed with status: " + interaction.status().orElse(null));
  }
  ```

  {% /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, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      // 1. Define the custom function
      getWeatherTool := interactions.NewTool(interactions.Function{
          Name:        genai.Ptr("get_weather"),
          Description: genai.Ptr("Gets the current weather for a given location."),
          Parameters: map[string]any{
              "type": "object",
              "properties": map[string]any{
                  "location": map[string]any{
                      "type":        "string",
                      "description": "The city and country, e.g. San Francisco, USA",
                  },
              },
              "required": []string{"location"},
          },
      })
  
      // 2. Call the agent with the custom tool (Turn 1)
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent:       interactions.AgentOption("antigravity-preview-09-2026"),
              Input:       interactions.NewInteractionsInput("What is the weather in Tokyo?"),
              Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
              Tools: []interactions.Tool{
                  interactions.NewTool(interactions.CodeExecution{}), // Enable default code execution
                  getWeatherTool, // Add custom function
              },
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  
      interaction := res.Interaction
  
      // Check if the agent requested a function call
      if interaction.Status == interactions.InteractionStatusRequiresAction {
          executedCalls := make(map[string]bool)
          for _, step := range interaction.Steps {
              if fr := step.FunctionResultStep; fr != nil {
                  executedCalls[fr.CallID] = true
              }
          }
  
          var pendingCalls []*interactions.FunctionCallStep
          for _, step := range interaction.Steps {
              if fc := step.FunctionCallStep; fc != nil && !executedCalls[fc.ID] {
                  pendingCalls = append(pendingCalls, fc)
              }
          }
  
          if len(pendingCalls) > 0 {
              fcStep := pendingCalls[0]
              fmt.Printf("Function to call: %s (ID: %s)\n", fcStep.Name, fcStep.ID)
              fmt.Printf("Arguments: %v\n", fcStep.Arguments)
  
              // 3. Execute the function locally (simulated get_weather()) and send the result back (Turn 2)
              resultStep := interactions.FunctionResultStep{
                  Name:   genai.Ptr(fcStep.Name),
                  CallID: fcStep.ID,
                  Result: interactions.NewFunctionResultStepResultUnion(`{"temperature": 23, "unit": "celsius"}`),
              }
  
              followupRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
                  Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
                      Agent:                 interactions.AgentOption("antigravity-preview-09-2026"),
                      PreviousInteractionID: interaction.ID,
                      Environment:           genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(*interaction.EnvironmentID)),
                      Input: interactions.NewInteractionsInput([]interactions.Step{
                          interactions.NewStep(resultStep),
                      }),
                  }),
              })
              if err != nil {
                  log.Fatal(err)
              }
              if followupRes.Interaction.OutputText != nil {
                  fmt.Println(*followupRes.Interaction.OutputText)
              }
          } else {
              fmt.Println("No pending function calls.")
          }
      } else {
          fmt.Printf("Interaction completed with status: %s\n", interaction.Status)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

## MCP servers  {% id="mcp-servers" %}

You can connect the Antigravity agent to external tools by registering remote Model Context Protocol (MCP) servers. The agent supports remote MCP servers over streamable HTTP.

When registering an MCP server, you must specify the following fields in the `tools` array:

| Field | Type | Required | Description |
| :--- | :--- | :--- | :--- |
| `type` | string | Yes | Must be `"mcp_server"`. |
| `name` | string | Yes | A unique identifier for the server. Must be strictly lowercase and alphanumeric (matching `^[a-z0-9_-]+$`). |
| `url` | string | Yes | The endpoint URL of the remote MCP server. |
| `headers` | object | No | Custom headers (e.g., authentication) sent with requests. |
| `allowed_tools` | array | No | List of tool names allowed to be executed. If omitted, all tools are allowed. |

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```py
  from google import genai
  
  client = genai.Client(http_options={"api_version": "v1beta"})
  
  # Register a remote HTTP MCP server
  interaction = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input="What is the weather in Tokyo?",
      environment="remote",
      tools=[{
          "type": "mcp_server",
          "name": "weather", # Must be lowercase
          "url": "https://gemini-api-demos.uc.r.appspot.com/mcp"
      }]
  )
  
  print(interaction.output_text)
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from "@google/genai";
  
  const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
  
  const interaction = await client.interactions.create({
      agent: "antigravity-preview-09-2026",
      input: "What is the weather in Tokyo?",
      environment: "remote",
      tools: [{
          type: "mcp_server",
          name: "weather", // Must be lowercase
          url: "https://gemini-api-demos.uc.r.appspot.com/mcp"
      }]
  }, { timeout: 300000 });
  
  console.log(interaction.output_text);
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
        "agent": "antigravity-preview-09-2026",
        "input": "What is the weather in Tokyo?",
        "environment": "remote",
        "tools": [{
            "type": "mcp_server",
            "name": "weather",
            "url": "https://gemini-api-demos.uc.r.appspot.com/mcp"
        }]
    }'
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.interactions.MCPServer;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.List;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  
  // Register a remote HTTP MCP server
  CreateAgentInteraction params = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("What is the weather in Tokyo?"))
      .environment(CreateAgentInteractionEnvironment.of("remote"))
      .tools(List.of(
          MCPServer.builder()
              .name("weather") // Must be lowercase
              .url("https://gemini-api-demos.uc.r.appspot.com/mcp")
              .build()
      ))
      .build();
  
  Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  System.out.println(interaction.outputText().orElse(""));
  ```

  {% /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, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      // Register a remote HTTP MCP server
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent:       interactions.AgentOption("antigravity-preview-09-2026"),
              Input:       interactions.NewInteractionsInput("What is the weather in Tokyo?"),
              Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
              Tools: []interactions.Tool{
                  interactions.NewTool(interactions.MCPServer{
                      Name: genai.Ptr("weather"), // Must be lowercase
                      URL:  genai.Ptr("https://gemini-api-demos.uc.r.appspot.com/mcp"),
                  }),
              },
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
      if res.Interaction.OutputText != nil {
          fmt.Println(*res.Interaction.OutputText)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

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

For `antigravity-preview-09-2026`, the default model is **Gemini 4 Hydrogen** (`gemini-4-hydrogen`). If you omit `agent_config`, the agent defaults to `gemini-4-hydrogen`.

You can configure the underlying Gemini model using `agent_config` to optimize for speed, cost, or reasoning capability. For example, set `model` to **Gemini 4 Carbon** (`gemini-4-carbon`) for complex software engineering and reasoning tasks:

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  from google import genai
  
  client = genai.Client(http_options={"api_version": "v1beta"})
  
  interaction = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input="Summarize the key differences between functional and object-oriented programming.",
      environment="remote",
      agent_config={
          "type": "antigravity",
          "model": "gemini-4-carbon",
      },
  )
  
  print(interaction.output_text)
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from "@google/genai";
  
  const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
  
  const interaction = await client.interactions.create({
      agent: "antigravity-preview-09-2026",
      input: "Summarize the key differences between functional and object-oriented programming.",
      environment: "remote",
      agent_config: {
          type: "antigravity",
          model: "gemini-4-carbon",
      },
  }, { timeout: 300000 });
  
  console.log(interaction.output_text);
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
        "agent": "antigravity-preview-09-2026",
        "input": "Summarize the key differences between functional and object-oriented programming.",
        "environment": "remote",
        "agent_config": {
            "type": "antigravity",
            "model": "gemini-4-carbon"
        }
    }'
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.AntigravityAgentConfig;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  
  CreateAgentInteraction params = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("Summarize the key differences between functional and object-oriented programming."))
      .environment(CreateAgentInteractionEnvironment.of("remote"))
      .agentConfig(
          AntigravityAgentConfig.builder()
              .model("gemini-4-carbon")
              .build()
      )
      .build();
  
  Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  System.out.println(interaction.outputText().orElse(""));
  ```

  {% /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, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent:       interactions.AgentOption("antigravity-preview-09-2026"),
              Input:       interactions.NewInteractionsInput("Summarize the key differences between functional and object-oriented programming."),
              Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
              AgentConfig: genai.Ptr(interactions.NewCreateAgentInteractionAgentConfig(interactions.AntigravityAgentConfig{
                  Model: genai.Ptr("gemini-4-carbon"),
              })),
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
      if res.Interaction.OutputText != nil {
          fmt.Println(*res.Interaction.OutputText)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

The supported values for `agent_config.model` are:

| Model | Value in `agent_config.model` | Description |
| :--- | :--- | :--- |
| **Gemini 4 Hydrogen** (default) | `gemini-4-hydrogen` | Default Gemini 4 model bringing cutting-edge intelligence with speed and efficiency for everyday coding and agentic workflows. |
| **Gemini 4 Carbon** | `gemini-4-carbon` | Most capable frontier reasoning model for complex software engineering, deep problem solving, and long-horizon agentic tasks. |
| **Gemini 4 Argon** | `gemini-4-argon` | Our efficient Gemini 4 frontier reasoning model, delivering faster responses and lower token spend per turn compared to [Gemini 4 Carbon](/docs/whats-new-gemini-4-carbon) across software engineering and agentic tasks. |
| **Gemini 3.8 Flash** | `gemini-3.8-flash` | Balanced Gemini 3.8 Flash model for reasoning, coding, and tool use. |
| **Gemini 3.6 Flash** | `gemini-3.6-flash` | Balanced Flash model for general agentic workflows. |
| **Gemini 3.5 Flash-Lite** | `gemini-3.5-flash-lite` | Lightweight model optimized for low latency and cost-sensitive tasks. |

When creating a managed agent with `agents.create`, you configure the model in the exact same way by passing `base_agent` and `agent_config`. Notice that you cannot override the model at interaction time for a managed agent created with `agents.create`. The model is locked to what was set when the agent was created. This ensures predictable tool calling behavior, consistent debugging, and adherence to security boundaries.

## Customizing the agent  {% id="customizing-the-agent" %}

You can extend the Antigravity agent by customizing its instructions, tools, and environment. The agent supports a filesystem-native approach to customization: you can mount files like `AGENTS.md` for instructions and skills under `.agents/skills/` directly into the sandbox, or pass configuration inline at interaction time. You can iterate on your configuration inline and then save it as a managed agent when you are ready.

For full details on how to build custom agents, see [Building Managed Agents](/docs/custom-agents).

## Background execution  {% id="background-execution" %}

Agent tasks that involve multi-step reasoning, code execution, or file operations can take minutes to complete. Use `background=True` to run the interaction asynchronously. The API returns immediately with an interaction ID that you poll until the status is `completed` or `failed`.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  import time
  from google import genai
  
  client = genai.Client(http_options={"api_version": "v1beta"})
  
  # 1. Start the interaction in the background
  interaction = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input="Run a complex analysis on the repository.",
      environment="remote",
      background=True,
  )
  
  print(f"Interaction started in background: {interaction.id}")
  
  # 2. Poll for completion
  while interaction.status == "in_progress":
      time.sleep(5)
      interaction = client.interactions.get(id=interaction.id)
  
  if interaction.status == "completed":
      print(interaction.output_text)
  else:
      print(f"Finished with status: {interaction.status}")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from "@google/genai";
  
  const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
  
  const interaction = await client.interactions.create({
      agent: "antigravity-preview-09-2026",
      input: "Run a complex analysis on the repository.",
      environment: "remote",
      background: true,
  });
  
  console.log(`Interaction started in background: ${interaction.id}`);
  
  let result = interaction;
  while (result.status === "in_progress") {
      await new Promise(resolve => setTimeout(resolve, 5000));
      result = await client.interactions.get(interaction.id);
  }
  
  if (result.status === "completed") {
      console.log(result.output_text);
  } else {
      console.log(`Finished with status: ${result.status}`);
  }
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  # 1. Start the interaction in the background
  RESPONSE=$(curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H "Api-Revision: 2026-05-20" \
    -d '{
        "agent": "antigravity-preview-09-2026",
        "input": "Run a complex analysis on the repository.",
        "environment": "remote",
        "background": true
    }')
  
  INTERACTION_ID=$(echo $RESPONSE | jq -r '.id')
  
  # 2. Poll for results (repeat until status is "completed")
  curl -s -X GET "https://generativelanguage.googleapis.com/v1beta/interactions/$INTERACTION_ID" \
    -H "x-goog-api-key: $GEMINI_API_KEY"
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionStatus;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import com.google.genai.gaos.models.operations.GetInteractionByIdRequest;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  
  // 1. Start the interaction in the background
  CreateAgentInteraction params = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("Run a complex analysis on the repository."))
      .environment(CreateAgentInteractionEnvironment.of("remote"))
      .background(true)
      .build();
  
  Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  System.out.println("Interaction started in background: " + interaction.id().orElse(""));
  
  // 2. Poll for completion
  while (interaction.status().orElse(null) == InteractionStatus.IN_PROGRESS) {
      Thread.sleep(5000);
      interaction = client.interactions.get(new GetInteractionByIdRequest(interaction.id().orElse(""))).interaction().get();
  }
  
  if (interaction.status().orElse(null) == InteractionStatus.COMPLETED) {
      System.out.println(interaction.outputText().orElse(""));
  } else {
      System.out.println("Finished with status: " + interaction.status().orElse(null));
  }
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "fmt"
      "log"
      "time"
  
      "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, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      // 1. Start the interaction in the background
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent:       interactions.AgentOption("antigravity-preview-09-2026"),
              Input:       interactions.NewInteractionsInput("Run a complex analysis on the repository."),
              Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
              Background:  genai.Ptr(true),
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  
      interaction := res.Interaction
      fmt.Printf("Interaction started in background: %s\n", *interaction.ID)
  
      // 2. Poll for completion
      for interaction.Status == interactions.InteractionStatusInProgress {
          time.Sleep(5 * time.Second)
          getRes, err := client.Interactions.Get(ctx, operations.GetInteractionByIDRequest{
              ID: *interaction.ID,
          })
          if err != nil {
              log.Fatal(err)
          }
          interaction = getRes.Interaction
      }
  
      if interaction.Status == interactions.InteractionStatusCompleted {
          if interaction.OutputText != nil {
              fmt.Println(*interaction.OutputText)
          }
      } else {
          fmt.Printf("Finished with status: %s\n", interaction.Status)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

Background execution requires `store=True`, which is the default. For real-time progress updates during background execution, see [Streaming background interactions](/docs/background-execution#streaming-pattern).

You can cancel a running background interaction using the `cancel` method.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  client.interactions.cancel(id="INTERACTION_ID")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  await client.interactions.cancel("INTERACTION_ID");
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions/INTERACTION_ID:cancel" \
    -H "x-goog-api-key: $GEMINI_API_KEY"
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  client.interactions.cancel("INTERACTION_ID");
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "log"
  
      "google.golang.org/genai"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      _, err = client.Interactions.Cancel(ctx, operations.CancelInteractionByIDRequest{
          ID: "INTERACTION_ID",
      })
      if err != nil {
          log.Fatal(err)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

**Multi-turn with background execution**

When a background interaction involves stateful tools (like code execution in a sandbox), use the `environment_id` from the completed interaction to continue in the same environment. This ensures the agent picks up where it left off with all files and state intact.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  import time
  from google import genai
  
  client = genai.Client(http_options={"api_version": "v1beta"})
  
  # First turn: run a task in the background
  interaction = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input="Clone https://github.com/google/generative-ai-python and run its tests.",
      environment="remote",
      background=True,
  )
  
  while interaction.status == "in_progress":
      time.sleep(5)
      interaction = client.interactions.get(id=interaction.id)
  
  # Second turn: continue in the same environment
  followup = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input="Fix any failing tests and re-run them.",
      previous_interaction_id=interaction.id,
      environment=interaction.environment_id,
      background=True,
  )
  
  while followup.status == "in_progress":
      time.sleep(5)
      followup = client.interactions.get(id=followup.id)
  
  print(followup.output_text)
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from "@google/genai";
  
  const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
  
  // First turn: run a task in the background
  let interaction = await client.interactions.create({
      agent: "antigravity-preview-09-2026",
      input: "Clone https://github.com/google/generative-ai-python and run its tests.",
      environment: "remote",
      background: true,
  });
  
  while (interaction.status === "in_progress") {
      await new Promise(resolve => setTimeout(resolve, 5000));
      interaction = await client.interactions.get(interaction.id);
  }
  
  // Second turn: continue in the same environment
  let followup = await client.interactions.create({
      agent: "antigravity-preview-09-2026",
      input: "Fix any failing tests and re-run them.",
      previous_interaction_id: interaction.id,
      environment: interaction.environment_id,
      background: true,
  });
  
  while (followup.status === "in_progress") {
      await new Promise(resolve => setTimeout(resolve, 5000));
      followup = await client.interactions.get(followup.id);
  }
  
  console.log(followup.output_text);
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  # 1. Start first interaction in the background
  RESPONSE=$(curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H "Api-Revision: 2026-05-20" \
    -d '{
        "agent": "antigravity-preview-09-2026",
        "input": "Clone https://github.com/google/generative-ai-python and run its tests.",
        "environment": "remote",
        "background": true
    }')
  
  INTERACTION_ID=$(echo $RESPONSE | jq -r '.id')
  
  # 2. Poll until completed (repeat until status is "completed")
  RESULT=$(curl -s -X GET "https://generativelanguage.googleapis.com/v1beta/interactions/$INTERACTION_ID" \
    -H "x-goog-api-key: $GEMINI_API_KEY")
  
  ENVIRONMENT_ID=$(echo $RESULT | jq -r '.environment_id')
  
  # 3. Continue in the same environment
  curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H "Api-Revision: 2026-05-20" \
    -d "{
        \"agent\": \"antigravity-preview-09-2026\",
        \"input\": \"Fix any failing tests and re-run them.\",
        \"previous_interaction_id\": \"$INTERACTION_ID\",
        \"environment\": \"$ENVIRONMENT_ID\",
        \"background\": true
    }"
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionStatus;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import com.google.genai.gaos.models.operations.GetInteractionByIdRequest;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  
  // First turn: run a task in the background
  CreateAgentInteraction params = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("Clone https://github.com/google/generative-ai-python and run its tests."))
      .environment(CreateAgentInteractionEnvironment.of("remote"))
      .background(true)
      .build();
  
  Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  
  while (interaction.status().orElse(null) == InteractionStatus.IN_PROGRESS) {
      Thread.sleep(5000);
      interaction = client.interactions.get(new GetInteractionByIdRequest(interaction.id().orElse(""))).interaction().get();
  }
  
  // Second turn: continue in the same environment
  CreateAgentInteraction followupParams = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("Fix any failing tests and re-run them."))
      .previousInteractionId(interaction.id().orElse(""))
      .environment(CreateAgentInteractionEnvironment.of(interaction.environmentId().orElse("")))
      .background(true)
      .build();
  
  Interaction followup = client.interactions.create(CreateInteractionRequestBody.of(followupParams)).interaction().get();
  
  while (followup.status().orElse(null) == InteractionStatus.IN_PROGRESS) {
      Thread.sleep(5000);
      followup = client.interactions.get(new GetInteractionByIdRequest(followup.id().orElse(""))).interaction().get();
  }
  
  System.out.println(followup.outputText().orElse(""));
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "fmt"
      "log"
      "time"
  
      "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, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      // First turn: run a task in the background
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent:       interactions.AgentOption("antigravity-preview-09-2026"),
              Input:       interactions.NewInteractionsInput("Clone https://github.com/google/generative-ai-python and run its tests."),
              Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
              Background:  genai.Ptr(true),
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  
      interaction := res.Interaction
      for interaction.Status == interactions.InteractionStatusInProgress {
          time.Sleep(5 * time.Second)
          getRes, err := client.Interactions.Get(ctx, operations.GetInteractionByIDRequest{
              ID: *interaction.ID,
          })
          if err != nil {
              log.Fatal(err)
          }
          interaction = getRes.Interaction
      }
  
      // Second turn: continue in the same environment
      followupRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent:                 interactions.AgentOption("antigravity-preview-09-2026"),
              Input:                 interactions.NewInteractionsInput("Fix any failing tests and re-run them."),
              PreviousInteractionID: interaction.ID,
              Environment:           genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(*interaction.EnvironmentID)),
              Background:            genai.Ptr(true),
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  
      followup := followupRes.Interaction
      for followup.Status == interactions.InteractionStatusInProgress {
          time.Sleep(5 * time.Second)
          getRes, err := client.Interactions.Get(ctx, operations.GetInteractionByIDRequest{
              ID: *followup.ID,
          })
          if err != nil {
              log.Fatal(err)
          }
          followup = getRes.Interaction
      }
  
      if followup.OutputText != nil {
          fmt.Println(*followup.OutputText)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

## Environments  {% id="environments" %}

Each call creates or reuses a Linux sandbox. The `environment` parameter takes three forms:

| Form | Description |
| :--- | :--- |
| `"remote"` | Provision a fresh sandbox with default settings. |
| `"env_abc123"` | Reuse an existing environment by ID, preserving all files and state. |
| `{...}` | Full `EnvironmentConfig` with custom sources and network rules. |

See [Environments](/docs/agent-environment) for details on sources (Git, GCS, inline), networking, lifecycle, and resource limits.

## Triggers  {% id="triggers" %}

Triggers let you schedule an agent to run automatically on a cron schedule. A trigger binds an agent, environment, prompt, and schedule into a persistent resource that fires without manual intervention. Each execution reuses the same environment, so files created in one run persist and are visible to the next.

### Create a trigger

Create a trigger by specifying a cron schedule, time zone, and the interaction configuration. The trigger starts in `active` status and will fire on the next matching cron time. Save the returned `id` to manage the trigger in subsequent calls.

Because a trigger runs unattended on a schedule, reference a stored [credential](/docs/agent-credentials) rather than an inline token. The egress proxy resolves it on every run, and you rotate the secret without touching the trigger. Inline `transform` rules work here too, they just need you to update the trigger whenever the value changes.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  from google import genai
  
  client = genai.Client(http_options={"api_version": "v1beta"})
  
  trigger = client.triggers.create(
      schedule="0 9 * * *",
      time_zone="America/Argentina/Buenos_Aires",
      display_name="issue-solver",
      interaction={
          "agent": "antigravity-preview-09-2026",
          "input": "Review open PRs in my-org/my-app for new comments and address feedback. Close issues whose PRs were merged. Then check for new issues labeled 'accepted', skip any already tracked in /workspace/solved-issues/, fix the rest, and open a PR for each. Save reports to /workspace/solved-issues/.",
          "environment": {
              "type": "remote",
              "network": {
                  "allowlist": [
                      {
                          "domain": "api.github.com",
                          "credential": "github-production",
                      },
                      {"domain": "github.com"},
                  ]
              },
          },
      },
  )
  
  print(f"Trigger created: {trigger.id}")
  print(f"Next run: {trigger.next_run_time}")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from "@google/genai";
  
  const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
  
  const trigger = await client.triggers.create({
      schedule: "0 9 * * *",
      time_zone: "America/Argentina/Buenos_Aires",
      display_name: "issue-solver",
      interaction: {
          agent: "antigravity-preview-09-2026",
          input: [{
              type: "text",
              text: "Review open PRs in my-org/my-app for new comments and address feedback. Close issues whose PRs were merged. Then check for new issues labeled 'accepted', skip any already tracked in /workspace/solved-issues/, fix the rest, and open a PR for each. Save reports to /workspace/solved-issues/.",
          }],
          environment: {
              type: "remote",
              network: {
                  allowlist: [
                      {
                          domain: "api.github.com",
                          credential: "github-production",
                      },
                      { domain: "github.com" },
                  ],
              },
          },
      },
  });
  
  console.log(`Trigger created: ${trigger.id}`);
  console.log(`Next run: ${trigger.next_run_time}`);
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/triggers" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
        "schedule": "0 9 * * *",
        "time_zone": "America/Argentina/Buenos_Aires",
        "display_name": "issue-solver",
        "interaction": {
            "agent": "antigravity-preview-09-2026",
            "input": [{"type": "text", "text": "Review open PRs in my-org/my-app for new comments and address feedback. Close issues whose PRs were merged. Then check for new issues labeled accepted, skip any already tracked in /workspace/solved-issues/, fix the rest, and open a PR for each. Save reports to /workspace/solved-issues/."}],
            "environment": {
                "type": "remote",
                "network": {
                    "allowlist": [
                        {
                            "domain": "api.github.com",
                            "credential": "github-production"
                        },
                        {"domain": "github.com"}
                    ]
                }
            }
        }
    }'
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.gaos.GenAI;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.Allowlist;
  import com.google.genai.gaos.models.interactions.AllowlistEntry;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  import com.google.genai.gaos.models.interactions.Environment;
  import com.google.genai.gaos.models.interactions.EnvironmentNetworkEgressAllowlist;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.interactions.Network;
  import com.google.genai.gaos.models.interactions.Transform;
  import com.google.genai.gaos.models.shared.Security;
  import com.google.genai.gaos.models.triggers.Trigger;
  import com.google.genai.gaos.models.triggers.TriggerCreateParams;
  import java.util.List;
  import java.util.Map;
  
  GenAI client = GenAI.builder()
      .security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
      .build();
  
  Environment env = Environment.builder()
      .network(Network.of(
          EnvironmentNetworkEgressAllowlist.builder()
              .allowlist(Allowlist.of(List.of(
                  AllowlistEntry.builder()
                      .domain("api.github.com")
                      .transform(Transform.of(Map.of(
                          "Authorization", "Bearer ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
                      )))
                      .build(),
                  AllowlistEntry.builder()
                      .domain("github.com")
                      .build()
              )))
              .build()
      ))
      .build();
  
  CreateAgentInteraction interactionTemplate = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("Review open PRs in my-org/my-app for new comments and address feedback. Close issues whose PRs were merged. Then check for new issues labeled 'accepted', skip any already tracked in /workspace/solved-issues/, fix the rest, and open a PR for each. Save reports to /workspace/solved-issues/."))
      .environment(CreateAgentInteractionEnvironment.of(env))
      .build();
  
  TriggerCreateParams params = TriggerCreateParams.builder()
      .schedule("0 9 * * *")
      .timeZone("America/Argentina/Buenos_Aires")
      .displayName("issue-solver")
      .interaction(interactionTemplate)
      .build();
  
  Trigger trigger = client.triggers().create(params).trigger().get();
  System.out.println("Trigger created: " + trigger.id().orElse(""));
  System.out.println("Next run: " + trigger.nextRunTime().orElse(null));
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "fmt"
      "log"
      "os"
  
      "google.golang.org/genai"
      interactionssdk "google.golang.org/genai/interactions"
      "google.golang.org/genai/interactions/models/components"
      "google.golang.org/genai/interactions/models/interactions"
      "google.golang.org/genai/interactions/models/operations"
      "google.golang.org/genai/interactions/models/triggers"
  )
  
  func main() {
      ctx := context.Background()
      sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
          APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
      }))
  
      env := interactions.Environment{
          Network: genai.Ptr(interactions.NewNetwork(interactions.EnvironmentNetworkEgressAllowlist{
              Allowlist: genai.Ptr(interactions.NewAllowlist([]interactions.AllowlistEntry{
                  {
                      Domain: "api.github.com",
                      Transform: genai.Ptr(interactions.NewTransform(map[string]string{
                          "Authorization": "Bearer ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
                      })),
                  },
                  {
                      Domain: "github.com",
                  },
              })),
          })),
      }
  
      interactionTemplate := interactions.CreateAgentInteraction{
          Agent:       interactions.AgentOption("antigravity-preview-09-2026"),
          Input:       interactions.NewInteractionsInput("Review open PRs in my-org/my-app for new comments and address feedback. Close issues whose PRs were merged. Then check for new issues labeled 'accepted', skip any already tracked in /workspace/solved-issues/, fix the rest, and open a PR for each. Save reports to /workspace/solved-issues/."),
          Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(env)),
      }
  
      res, err := sdk.Triggers.Create(ctx, operations.CreateTriggerRequest{
          Body: triggers.TriggerCreateParams{
              Schedule:    "0 9 * * *",
              TimeZone:    "America/Argentina/Buenos_Aires",
              DisplayName: genai.Ptr("issue-solver"),
              Interaction: interactionTemplate,
          },
      })
      if err != nil {
          log.Fatal(err)
      }
  
      trigger := res.Trigger
      fmt.Printf("Trigger created: %s\n", trigger.ID)
      fmt.Printf("Next run: %v\n", trigger.NextRunTime)
  }
  ```

  {% /tab %}

{% /tabs %}

The `CreateTrigger` request accepts the following fields:

| Field | Type | Required | Description |
| :--- | :--- | :--- | :--- |
| `schedule` | string | Yes | Cron expression (e.g., `0 * * * *` for hourly, `0 9 * * 1-5` for weekday mornings). |
| `time_zone` | string | Yes | IANA time zone (e.g., `UTC`, `America/Argentina/Buenos_Aires`). |
| `display_name` | string | No | Human-readable name for the trigger. |
| `max_consecutive_failures` | integer | No | Max failures before the trigger is automatically paused. Default: 5. |
| `execution_timeout_seconds` | integer | No | Timeout per execution in seconds. Default: 600. |
| `interaction` | object | Yes | A `CreateInteractionRequest` defining the agent, input, tools, and environment. |

The response includes the following key fields:

| Field | Type | Description |
| :--- | :--- | :--- |
| `id` | string | Unique identifier for the trigger. Use this in all subsequent operations. |
| `status` | string | Current state: `active`, `paused`, or `disabled`. |
| `next_run_time` | string | ISO 8601 timestamp of the next scheduled execution. |
| `consecutive_failure_count` | integer | Number of consecutive failed executions since the last success. |

### List triggers

Retrieve all triggers associated with your project.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  triggers = client.triggers.list()
  for trigger in triggers.triggers:
      print(f"{trigger.id}: {trigger.display_name} ({trigger.status})")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  const triggers = await client.triggers.list();
  for (const trigger of triggers.triggers) {
      console.log(`${trigger.id}: ${trigger.display_name} (${trigger.status})`);
  }
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X GET "https://generativelanguage.googleapis.com/v1beta/triggers" \
    -H "x-goog-api-key: $GEMINI_API_KEY"
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.gaos.GenAI;
  import com.google.genai.gaos.models.shared.Security;
  import com.google.genai.gaos.models.triggers.Trigger;
  import java.util.List;
  
  GenAI client = GenAI.builder()
      .security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
      .build();
  
  List<Trigger> triggers = client.triggers().listDirect().listTriggersResponse().get().triggers().orElse(List.of());
  for (Trigger trigger : triggers) {
      System.out.println(trigger.id().orElse("") + ": " + trigger.displayName().orElse("") + " (" + trigger.status().orElse(null) + ")");
  }
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "fmt"
      "log"
      "os"
  
      "google.golang.org/genai"
      interactionssdk "google.golang.org/genai/interactions"
      "google.golang.org/genai/interactions/models/components"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
          APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
      }))
  
      res, err := sdk.Triggers.List(ctx, operations.ListTriggersRequest{})
      if err != nil {
          log.Fatal(err)
      }
  
      if res.ListTriggersResponse != nil {
          for _, trigger := range res.ListTriggersResponse.Triggers {
              fmt.Printf("%s: %s (%v)\n", trigger.ID, *trigger.GetDisplayName(), trigger.Status)
          }
      }
  }
  ```

  {% /tab %}

{% /tabs %}

### Get a trigger

Fetch the full configuration and current state of a single trigger.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  trigger = client.triggers.get(id="TRIGGER_ID")
  print(f"Schedule: {trigger.schedule}")
  print(f"Next run: {trigger.next_run_time}")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  const trigger = await client.triggers.get("TRIGGER_ID");
  console.log(`Schedule: ${trigger.schedule}`);
  console.log(`Next run: ${trigger.next_run_time}`);
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X GET "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID" \
    -H "x-goog-api-key: $GEMINI_API_KEY"
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.gaos.GenAI;
  import com.google.genai.gaos.models.shared.Security;
  import com.google.genai.gaos.models.triggers.Trigger;
  
  GenAI client = GenAI.builder()
      .security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
      .build();
  
  Trigger trigger = client.triggers().get("TRIGGER_ID").trigger().get();
  System.out.println("Schedule: " + trigger.schedule().orElse(""));
  System.out.println("Next run: " + trigger.nextRunTime().orElse(null));
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "fmt"
      "log"
      "os"
  
      "google.golang.org/genai"
      interactionssdk "google.golang.org/genai/interactions"
      "google.golang.org/genai/interactions/models/components"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
          APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
      }))
  
      res, err := sdk.Triggers.Get(ctx, operations.GetTriggerRequest{
          ID: "TRIGGER_ID",
      })
      if err != nil {
          log.Fatal(err)
      }
  
      fmt.Printf("Schedule: %s\n", res.Trigger.Schedule)
      fmt.Printf("Next run: %v\n", res.Trigger.NextRunTime)
  }
  ```

  {% /tab %}

{% /tabs %}

### Pause and resume

You can pause a trigger to stop scheduled executions, and resume it to reactivate the schedule. Pausing does not affect manual executions.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  # Pause
  client.triggers.update(id="TRIGGER_ID", status="paused")
  
  # Resume
  client.triggers.update(id="TRIGGER_ID", status="active")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  // Pause
  await client.triggers.update("TRIGGER_ID", { status: "paused" });
  
  // Resume
  await client.triggers.update("TRIGGER_ID", { status: "active" });
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  # Pause
  curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{"status": "paused"}'
  
  # Resume
  curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{"status": "active"}'
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.gaos.GenAI;
  import com.google.genai.gaos.models.shared.Security;
  import com.google.genai.gaos.models.triggers.TriggerUpdate;
  import com.google.genai.gaos.models.triggers.TriggerUpdateStatus;
  
  GenAI client = GenAI.builder()
      .security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
      .build();
  
  // Pause
  client.triggers().update("TRIGGER_ID", TriggerUpdate.builder().status(TriggerUpdateStatus.PAUSED).build());
  
  // Resume
  client.triggers().update("TRIGGER_ID", TriggerUpdate.builder().status(TriggerUpdateStatus.ACTIVE).build());
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "log"
      "os"
  
      "google.golang.org/genai"
      interactionssdk "google.golang.org/genai/interactions"
      "google.golang.org/genai/interactions/models/components"
      "google.golang.org/genai/interactions/models/operations"
      "google.golang.org/genai/interactions/models/triggers"
  )
  
  func main() {
      ctx := context.Background()
      sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
          APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
      }))
  
      // Pause
      _, err := sdk.Triggers.Update(ctx, operations.UpdateTriggerRequest{
          ID: "TRIGGER_ID",
          Body: triggers.TriggerUpdate{
              Status: triggers.TriggerUpdateStatusPaused.ToPointer(),
          },
      })
      if err != nil {
          log.Fatal(err)
      }
  
      // Resume
      _, err = sdk.Triggers.Update(ctx, operations.UpdateTriggerRequest{
          ID: "TRIGGER_ID",
          Body: triggers.TriggerUpdate{
              Status: triggers.TriggerUpdateStatusActive.ToPointer(),
          },
      })
      if err != nil {
          log.Fatal(err)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

### Delete a trigger

Permanently remove a trigger. Past execution history is not deleted.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  client.triggers.delete(id="TRIGGER_ID")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  await client.triggers.delete("TRIGGER_ID");
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID" \
    -H "x-goog-api-key: $GEMINI_API_KEY"
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.gaos.GenAI;
  import com.google.genai.gaos.models.shared.Security;
  
  GenAI client = GenAI.builder()
      .security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
      .build();
  
  client.triggers().delete("TRIGGER_ID");
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "log"
      "os"
  
      "google.golang.org/genai"
      interactionssdk "google.golang.org/genai/interactions"
      "google.golang.org/genai/interactions/models/components"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
          APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
      }))
  
      _, err := sdk.Triggers.Delete(ctx, operations.DeleteTriggerRequest{
          ID: "TRIGGER_ID",
      })
      if err != nil {
          log.Fatal(err)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

### Run a trigger immediately

Fire a trigger on demand without waiting for the next scheduled time. This works even if the trigger is paused.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  client.triggers.run(trigger_id="TRIGGER_ID")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  await client.triggers.run("TRIGGER_ID");
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID/executions" \
    -H "x-goog-api-key: $GEMINI_API_KEY"
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.gaos.GenAI;
  import com.google.genai.gaos.models.shared.Security;
  
  GenAI client = GenAI.builder()
      .security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
      .build();
  
  client.triggers().run("TRIGGER_ID");
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "log"
      "os"
  
      "google.golang.org/genai"
      interactionssdk "google.golang.org/genai/interactions"
      "google.golang.org/genai/interactions/models/components"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
          APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
      }))
  
      _, err := sdk.Triggers.Run(ctx, operations.RunTriggerRequest{
          TriggerID: "TRIGGER_ID",
      })
      if err != nil {
          log.Fatal(err)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

### List executions

View the execution history for a trigger. Each execution includes a `status`, timestamps, an `interaction_id` you can use to fetch the full interaction output, and an `environment_id` confirming that all runs share the same sandbox.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  executions = client.triggers.list_executions(trigger_id="TRIGGER_ID")
  for ex in executions.trigger_executions:
      print(f"{ex.id}: {ex.status} ({ex.start_time} - {ex.end_time})")
  
  # Fetch the full interaction for an execution
  interaction = client.interactions.get(id=ex.interaction_id)
  print(interaction.output_text)
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  const executions = await client.triggers.listExecutions("TRIGGER_ID");
  for (const ex of executions.trigger_executions) {
      console.log(`${ex.id}: ${ex.status} (${ex.start_time} - ${ex.end_time})`);
  }
  
  // Fetch the full interaction for an execution
  const interaction = await client.interactions.get(ex.interaction_id);
  console.log(interaction.output_text);
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X GET "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID/executions" \
    -H "x-goog-api-key: $GEMINI_API_KEY"
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.gaos.GenAI;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.operations.GetInteractionByIdRequest;
  import com.google.genai.gaos.models.shared.Security;
  import com.google.genai.gaos.models.triggers.TriggerExecution;
  import java.util.List;
  
  GenAI client = GenAI.builder()
      .security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
      .build();
  
  List<TriggerExecution> executions = client.triggers().listExecutions("TRIGGER_ID")
      .listTriggerExecutionsResponse().get()
      .triggerExecutions().orElse(List.of());
  
  for (TriggerExecution ex : executions) {
      System.out.println(ex.id().orElse("") + ": " + ex.status().orElse(null)
          + " (" + ex.startTime().orElse(null) + " - " + ex.endTime().orElse(null) + ")");
  
      // Fetch the full interaction for an execution
      if (ex.interactionId().isPresent()) {
          Interaction interaction = client.interactions().get(new GetInteractionByIdRequest(ex.interactionId().get())).interaction().get();
          System.out.println(interaction.outputText().orElse(""));
      }
  }
  ```

  {% /tab %}

  {% tab label="Go" %}
  ```go
  package main
  
  import (
      "context"
      "fmt"
      "log"
      "os"
  
      "google.golang.org/genai"
      interactionssdk "google.golang.org/genai/interactions"
      "google.golang.org/genai/interactions/models/components"
      "google.golang.org/genai/interactions/models/operations"
  )
  
  func main() {
      ctx := context.Background()
      sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
          APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
      }))
  
      res, err := sdk.Triggers.ListExecutions(ctx, operations.ListTriggerExecutionsRequest{
          TriggerID: "TRIGGER_ID",
      })
      if err != nil {
          log.Fatal(err)
      }
  
      if res.ListTriggerExecutionsResponse != nil {
          for _, ex := range res.ListTriggerExecutionsResponse.TriggerExecutions {
              fmt.Printf("%s: %v (%v - %v)\n", ex.ID, ex.Status, ex.StartTime, ex.EndTime)
  
              // Fetch the full interaction for an execution
              if ex.InteractionID != nil {
                  intRes, err := sdk.Interactions.Get(ctx, operations.GetInteractionByIDRequest{
                      ID: *ex.InteractionID,
                  })
                  if err != nil {
                      log.Fatal(err)
                  }
                  if intRes.Interaction.OutputText != nil {
                      fmt.Println(*intRes.Interaction.OutputText)
                  }
              }
          }
      }
  }
  ```

  {% /tab %}

{% /tabs %}

## Availability and pricing  {% id="availability-and-pricing" %}

Antigravity agent is available in preview through the
[Interactions API](/docs/interactions-overview) in Google AI Studio
and the Gemini API for both free tier and paid tier projects.

Pricing follows a [pay-as-you-go model](/docs/pricing#pricing-for-agents)
based on the underlying Gemini model tokens and the tools the agent uses. Unlike a
standard chat request that produces a single output, an Antigravity interaction is an
agentic workflow. A single request triggers an autonomous loop of reasoning, tool
execution, code running, and file management. Free tier projects include a free rate limit
and usage quota.

Antigravity interactions run multi-turn autonomous loops and can consume
significant tokens. Set [budget controls](/docs/antigravity-agent#budget-controls) on your request to
limit token usage. You can also monitor progress in real time with
[SSE streaming](/docs/streaming), or cancel running requests.

### Budget controls  {% id="budget-controls" %}

In addition to [model selection](/docs/antigravity-agent#model-selection), set `max_total_tokens` inside `agent_config` (with `"type": "antigravity"`) to limit
the total number of tokens (input + output + thinking) an interaction can consume.
Cached tokens do not count toward this limit. When the agent reaches the limit, the
interaction stops and returns with `status: "incomplete"`. The limit is best-effort:
actual usage may slightly exceed it depending on when the agent checks the budget
between steps.

Set the budget on the interaction request in `agent_config` alongside `agent` and `input`.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  from google import genai
  
  client = genai.Client(http_options={"api_version": "v1beta"})
  
  interaction = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input="Analyze the dataset in /workspace/data.csv and generate a summary report.",
      agent_config={
          "type": "antigravity",
          "max_total_tokens": 50000
      },
      environment={
          "type": "remote",
          "sources": [
              {
                  "type": "inline",
                  "target": "/workspace/data.csv",
                  "content": "id,name,value\n1,alpha,100\n2,beta,200\n",
              }
          ],
      }
  )
  print(f"Status: {interaction.status}")  # "incomplete" if budget was hit
  print(f"Tokens used: {interaction.usage.total_tokens}")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  import { GoogleGenAI } from "@google/genai";
  
  const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
  
  const interaction = await client.interactions.create({
      agent: "antigravity-preview-09-2026",
      input: "Analyze the dataset in /workspace/data.csv and generate a summary report.",
      agent_config: {
          type: "antigravity",
          max_total_tokens: "50000"
      },
      environment: {
          type: "remote",
          sources: [
              {
                  type: "inline",
                  target: "/workspace/data.csv",
                  content: "id,name,value\n1,alpha,100\n2,beta,200\n",
              },
          ],
      },
  });
  console.log(`Status: ${interaction.status}`);
  console.log(`Tokens used: ${interaction.usage?.total_tokens}`);
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
      "agent": "antigravity-preview-09-2026",
      "input": "Analyze the dataset in /workspace/data.csv and generate a summary report.",
      "agent_config": {
        "type": "antigravity",
        "max_total_tokens": 50000
      },
      "environment": {
        "type": "remote",
        "sources": [
          {
            "type": "inline",
            "target": "/workspace/data.csv",
            "content": "id,name,value\n1,alpha,100\n2,beta,200\n"
          }
        ]
      }
    }'
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.AntigravityAgentConfig;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  import com.google.genai.gaos.models.interactions.Environment;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.interactions.Source;
  import com.google.genai.gaos.models.interactions.SourceType;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  import java.util.List;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  
  Environment env = Environment.builder()
      .sources(List.of(
          Source.builder()
              .type(SourceType.INLINE)
              .target("/workspace/data.csv")
              .content("id,name,value\n1,alpha,100\n2,beta,200\n")
              .build()
      ))
      .build();
  
  CreateAgentInteraction params = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("Analyze the dataset in /workspace/data.csv and generate a summary report."))
      .agentConfig(
          AntigravityAgentConfig.builder()
              .maxTotalTokens("50000")
              .build()
      )
      .environment(CreateAgentInteractionEnvironment.of(env))
      .build();
  
  Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  System.out.println("Status: " + interaction.status().orElse(null)); // "incomplete" if budget was hit
  interaction.usage().ifPresent(usage -> System.out.println("Tokens used: " + usage.totalTokens().orElse(0)));
  ```

  {% /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, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      env := interactions.Environment{
          Sources: []interactions.Source{
              {
                  Type:    interactions.SourceTypeInline.ToPointer(),
                  Target:  genai.Ptr("/workspace/data.csv"),
                  Content: genai.Ptr("id,name,value\n1,alpha,100\n2,beta,200\n"),
              },
          },
      }
  
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent: interactions.AgentOption("antigravity-preview-09-2026"),
              Input: interactions.NewInteractionsInput("Analyze the dataset in /workspace/data.csv and generate a summary report."),
              AgentConfig: genai.Ptr(interactions.NewCreateAgentInteractionAgentConfig(interactions.AntigravityAgentConfig{
                  MaxTotalTokens: genai.Ptr(int64(50000)),
              })),
              Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(env)),
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  
      interaction := res.Interaction
      fmt.Printf("Status: %s\n", interaction.Status) // "incomplete" if budget was hit
      if interaction.Usage != nil && interaction.Usage.TotalTokens != nil {
          fmt.Printf("Tokens used: %d\n", *interaction.Usage.TotalTokens)
      }
  }
  ```

  {% /tab %}

{% /tabs %}

#### Continuing an incomplete interaction  {% id="continuing-incomplete-interaction" %}

When an interaction returns `status: "incomplete"`, the agent's work and context
are preserved. Send a new interaction referencing the original interaction `id` and
`environment_id` to pick up where it left off. The new interaction gets its own
`max_total_tokens` budget.

{% tabs %}
  {% tab filename="sample.py" label="Python" %}
  ```python
  # Continue from where the agent stopped
  continuation = client.interactions.create(
      agent="antigravity-preview-09-2026",
      input="continue",
      previous_interaction_id=interaction.id,
      environment=interaction.environment_id,
      agent_config={
          "type": "antigravity",
          "max_total_tokens": 50000
      }
  )
  print(f"Status: {continuation.status}")
  ```

  {% /tab %}

  {% tab filename="sample.js" label="JavaScript" %}
  ```javascript
  const continuation = await client.interactions.create({
      agent: "antigravity-preview-09-2026",
      input: "continue",
      previous_interaction_id: interaction.id,
      environment: interaction.environment_id,
      agent_config: {
          type: "antigravity",
          max_total_tokens: "50000"
      }
  });
  console.log(`Status: ${continuation.status}`);
  ```

  {% /tab %}

  {% tab filename="sample.sh" label="REST" %}
  ```shell
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
      "agent": "antigravity-preview-09-2026",
      "input": "continue",
      "previous_interaction_id": "INTERACTION_ID",
      "environment": "ENVIRONMENT_ID",
      "agent_config": {
        "type": "antigravity",
        "max_total_tokens": 50000
      }
    }'
  ```

  {% /tab %}

  {% tab label="Java" %}
  ```java
  import com.google.genai.Client;
  import com.google.genai.types.HttpOptions;
  import com.google.genai.gaos.models.interactions.AgentOption;
  import com.google.genai.gaos.models.interactions.AntigravityAgentConfig;
  import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
  import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
  import com.google.genai.gaos.models.interactions.Interaction;
  import com.google.genai.gaos.models.interactions.InteractionsInput;
  import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
  
  Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
  String interactionId = "INTERACTION_ID";
  String environmentId = "ENVIRONMENT_ID";
  
  // Continue from where the agent stopped
  CreateAgentInteraction params = CreateAgentInteraction.builder()
      .agent(AgentOption.of("antigravity-preview-09-2026"))
      .input(InteractionsInput.of("continue"))
      .previousInteractionId(interactionId)
      .environment(CreateAgentInteractionEnvironment.of(environmentId))
      .agentConfig(
          AntigravityAgentConfig.builder()
              .maxTotalTokens("50000")
              .build()
      )
      .build();
  
  Interaction continuation = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
  System.out.println("Status: " + continuation.status().orElse(null));
  ```

  {% /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, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
      if err != nil {
          log.Fatal(err)
      }
  
      interactionID := "INTERACTION_ID"
      environmentID := "ENVIRONMENT_ID"
  
      // Continue from where the agent stopped
      res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
          Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
              Agent:                 interactions.AgentOption("antigravity-preview-09-2026"),
              Input:                 interactions.NewInteractionsInput("continue"),
              PreviousInteractionID: genai.Ptr(interactionID),
              Environment:           genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(environmentID)),
              AgentConfig: genai.Ptr(interactions.NewCreateAgentInteractionAgentConfig(interactions.AntigravityAgentConfig{
                  MaxTotalTokens: genai.Ptr(int64(50000)),
              })),
          }),
      })
      if err != nil {
          log.Fatal(err)
      }
  
      fmt.Printf("Status: %s\n", res.Interaction.Status)
  }
  ```

  {% /tab %}

{% /tabs %}

### Estimated costs

Costs vary based on task complexity. The agent autonomously determines how many tool calls, code executions, and file operations are needed. The following estimates are based on runs.

| Task category | Input tokens | Output tokens | Typical cost |
| :--- | :--- | :--- | :--- |
| **Research & information synthesis** | 100k–500k | 10k–40k | $0.30–$1.00 |
| **Document & content generation** | 100k–500k | 15k–50k | $0.30–$1.30 |
| **Process & system design** | 100k–400k | 10k–30k | $0.25–$0.80 |
| **Data processing & analysis** | 300k–3M | 30k–150k | $0.70–$3.25 |

50–70% of input tokens are typically cached. Complex agentic workflows with many tool calls can accumulate 3–5 million tokens in a single interaction, with costs up to \~$5.

**Environment compute** (CPU, memory, sandbox execution) is **not billed** during the preview period.

## Limitations  {% id="limitations" %}

- **Preview status:** The Antigravity agent and the Interactions API. Features and schemas may change.
- **Unsupported generation config:** The following parameters are not supported and return a 400 error: `temperature`, `top_p`, `top_k`, `stop_sequences`, `max_output_tokens`.
- **Structured output:** The Antigravity agent does not support structured outputs.
- **Unavailable tools:** `file_search`, `computer_use`, and `google_maps` are not yet supported.
- **Remote MCP limitations:** Server-Sent Events (SSE) transport is not supported (use Streamable HTTP). Additionally, the server `name` must be strictly lowercase and alphanumeric (using uppercase letters triggers a generic `400 Bad Request` error).
- **Filesystem tool:** There is no filesystem tool at the moment. It is part of the `environment`.
- **Store requirement:** Agent execution using `background=True` requires `store=True`.
- **Stateful only function calling:** Function calling is only supported in stateful mode. You must use `previous_interaction_id` to continue the turn; reconstructing history manually (stateless mode) is not supported.
- **Unsupported multimodal types.** Audio, video, and document inputs are not supported at the moment. Only text and image are allowed.

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

- [Quickstart](/docs/managed-agents-quickstart): multi-turn conversations and streaming.
- [Building Custom Agents](/docs/custom-agents): custom instructions, skills, and saving agents.
- [Environments](/docs/agent-environment): sandbox configuration, sources, networking.
- [Hooks](/docs/agent-hooks): enforce security gates and side-effect validation inside the sandbox.
- [Deep Research agent](/docs/deep-research): long-form research tasks.
- [Interactions API](/docs/interactions-overview): the underlying API.