Agent Antigravity

Agent Antigravity to zarządzany agent do zwykłych obciążeń w Gemini API. Pojedyncze wywołanie interfejsu API zapewnia dostęp do agenta, który może wnioskować, wykonywać kod, zarządzać plikami i przeglądać internet w bezpiecznej piaskownicy Linux hostowanej przez Google.

Jest on oparty na modelu Gemini 3.5 Flash i korzysta z tego samego szkieletu co Antigravity IDE. Jest dostępny przez Interactions API i Google AI Studio.

Python

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
    environment="remote",
)

print(interaction.output_text)

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    agent: "antigravity-preview-05-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);

REST

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-05-2026",
    "input": "Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
    "environment": "remote"
}'

Uprawnienia

Każde wywołanie może udostępnić piaskownicę Linux i uruchomić pętlę korzystania z narzędzi. Agent planuje, działa, obserwuje wyniki i powtarza te czynności, aż zadanie zostanie wykonane.

  • Wykonywanie kodu: uruchamiaj polecenia Bash, Python i Node.js. Instaluj pakiety, przeprowadzaj testy i twórz aplikacje.
  • Zarządzanie plikami: odczytuj, zapisuj, edytuj, wyszukuj i wyświetlaj pliki w piaskownicy. Pliki są zachowywane między interakcjami.
  • Dostęp do internetu: wyszukiwarka Google i pobieranie adresów URL w celu uzyskania danych.
  • Kompaktowanie kontekstu: automatyczne kompaktowanie kontekstu (wyzwalane przy ok. 135 tys. tokenów) w celu obsługi długotrwałych sesji wieloetapowych bez utraty kontekstu i przekroczenia limitów tokenów.

Więcej informacji o korzystaniu z wielu etapów i przesyłaniu strumieniowym znajdziesz w krótkim wprowadzeniu.

Obsługiwane narzędzia

Domyślnie agent ma dostęp do narzędzi code_execution, google_search i url_context. Narzędzia systemu plików są włączane automatycznie po określeniu parametru environment. Możesz też zdefiniować funkcje niestandardowe , aby połączyć agenta z własnymi interfejsami API i narzędziami. Parametr tools musisz określić tylko wtedy, gdy dostosowujesz lub ograniczasz domyślny zestaw narzędzi albo dodajesz funkcje niestandardowe.

Narzędzie Wartość typu Opis
Wykonywanie kodu code_execution Uruchamiaj polecenia powłoki (Bash, Python, Node) z przechwytywaniem stdout/stderr.
Wyszukiwarka Google google_search Szukaj w całej sieci publicznej.
Kontekst adresu URL url_context Pobieraj i odczytuj strony internetowe.
System plików (włączone przez environment) Odczytuj, zapisuj, edytuj, wyszukuj i wyświetlaj pliki w piaskownicy. Brak osobnego typu narzędzia. Włączane automatycznie po ustawieniu parametru environment.
Funkcje niestandardowe function Definiuj funkcje niestandardowe, które agent może wywoływać. Zobacz Wywoływanie funkcji.
Zdalny serwer MCP mcp_server Rejestruj zewnętrzne serwery Model Context Protocol (MCP) jako narzędzia. Zobacz Serwery MCP.

Aby ograniczyć agenta do określonych narzędzi, przekaż tylko te, których potrzebujesz:

Python

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    agent="antigravity-preview-05-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)

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    agent: "antigravity-preview-05-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);

REST

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-05-2026",
    "input": "Search for the latest AI research papers on reasoning and summarize them.",
    "environment": "remote",
    "tools": [
        {"type": "google_search"},
        {"type": "url_context"}
    ]
}'

Wielomodalne dane wejściowe

Agent Antigravity obsługuje wielomodalne dane wejściowe. Obecnie obsługiwane są tylko dane wejściowe text i image. Obrazy muszą być podawane jako ciągi tekstowe z kodowaniem Base64 (data).

Python

import base64
from google import genai

client = genai.Client()

with open("path/to/chart.png", "rb") as f:
    image_bytes = f.read()

interaction_inline = client.interactions.create(
    agent="antigravity-preview-05-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",
)

JavaScript


import { GoogleGenAI } from "@google/genai";

import * as fs from "node:fs";

const client = new GoogleGenAI({});
const base64Image = fs.readFileSync("path/to/chart.png", { encoding: "base64" });

const interactionInline = await client.interactions.create({
    agent: "antigravity-preview-05-2026",
    input: [
        { type: "text", text: "Analyze this chart and summarize the trends." },
        {
            type: "image",
            data: base64Image,
            mime_type: "image/png",
        },
    ],
    environment: "remote",
}, { timeout: 300000 });

REST

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-05-2026\",
    \"input\": [
        {\"type\": \"text\", \"text\": \"Analyze this chart and summarize the trends.\"},
        {
            \"type\": \"image\",
            \"mime_type\": \"image/png\",
            \"data\": \"$BASE64_IMAGE\"
        }
    ],
    \"environment\": \"remote\"
}"

Wywoływanie funkcji

Wywoływanie funkcji umożliwia łączenie agenta Antigravity z zewnętrznymi interfejsami API i bazami danych przez definiowanie niestandardowych narzędzi, które agent może wywoływać. Ogólne informacje znajdziesz w artykule Wywoływanie funkcji za pomocą Gemini API.

Poniższy przykład przedstawia interakcję 2-etapową. Najpierw agent prosi o wywołanie funkcji niestandardowej get_weather, a klient ją wykonuje i zwraca wynik w drugim etapie.

Python

from google import genai

client = genai.Client()

# 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-05-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_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-05-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}")

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

// 1. Define the custom function
const 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)
const interaction = await client.interactions.create({
  agent: "antigravity-preview-05-2026",
  input: "What is the weather in Tokyo?",
  environment: "remote",
  tools: [
    { type: "code_execution" },
    get_weather_tool,
  ],
}, { timeout: 300000 });

if (interaction.status === "requires_action") {
  // Find function calls that do not have a matching function result.
  // Filesystem tools (like write_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];
    console.log(`Function to call: ${fcStep.name} (ID: ${fcStep.id})`);

    // 3. 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-05-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}`);
}

REST

# 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-05-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-05-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\"
              }
          }
      ]
  }"

Serwery MCP

Możesz połączyć agenta Antigravity z narzędziami zewnętrznymi, rejestrując zdalne serwery Model Context Protocol (MCP). Agent obsługuje zdalne serwery MCP przez strumieniowy protokół HTTP.

Podczas rejestrowania serwera MCP musisz określić te pola w tablicy tools:

Pole Typ Wymagane Opis
type ciąg znaków Tak Musi to być wartość "mcp_server".
name ciąg znaków Tak Unikalny identyfikator serwera. Musi składać się wyłącznie z małych liter i znaków alfanumerycznych (zgodnie z wyrażeniem ^[a-z0-9_-]+$).
url ciąg znaków Tak Adres URL punktu końcowego zdalnego serwera MCP.
headers obiekt Nie Niestandardowe nagłówki (np. uwierzytelniania) wysyłane z żądaniami.
allowed_tools tablica Nie Lista nazw narzędzi, które można uruchamiać. Jeśli pominiesz ten parametr, dozwolone będą wszystkie narzędzia.

Python

from google import genai

client = genai.Client()

# Register a remote HTTP MCP server
interaction = client.interactions.create(
    agent="antigravity-preview-05-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)

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    agent: "antigravity-preview-05-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);

REST

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-05-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"
      }]
  }'

Dostosowywanie agenta

Możesz rozszerzyć możliwości agenta Antigravity, dostosowując jego instrukcje, narzędzia i środowisko. Agent obsługuje podejście do dostosowywania oparte na systemie plików: możesz zamontować pliki, takie jak AGENTS.md, z instrukcjami i umiejętnościami bezpośrednio w piaskownicy w folderze .agents/skills/ lub przekazać konfigurację w tekście podczas interakcji. Możesz iterować konfigurację w tekście, a potem zapisać ją jako zarządzanego agenta.

Szczegółowe informacje o tworzeniu niestandardowych agentów znajdziesz w artykule Tworzenie zarządzanych agentów.

Wykonywanie w tle

Zadania agenta, które wymagają wieloetapowego wnioskowania, wykonywania kodu lub operacji na plikach, mogą potrwać kilka minut. Aby uruchomić interakcję asynchronicznie, użyj parametru background=True. Interfejs API natychmiast zwraca identyfikator interakcji, który możesz sondować, aż stan zmieni się na completed lub failed.

Python

import time
from google import genai

client = genai.Client()

# 1. Start the interaction in the background
interaction = client.interactions.create(
    agent="antigravity-preview-05-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}")

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    agent: "antigravity-preview-05-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}`);
}

REST

# 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-05-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"

Wykonywanie w tle wymaga ustawienia store=True, które jest domyślne. Aby otrzymywać aktualizacje postępu w czasie rzeczywistym podczas wykonywania w tle, zobacz Przesyłanie strumieniowe interakcji w tle.

Możesz anulować trwającą interakcję w tle za pomocą metody cancel.

Python

client.interactions.cancel(id="INTERACTION_ID")

JavaScript

await client.interactions.cancel({ id: "INTERACTION_ID" });

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions/INTERACTION_ID:cancel" \
  -H "x-goog-api-key: $GEMINI_API_KEY"

Wieloetapowe wykonywanie w tle

Gdy interakcja w tle obejmuje narzędzia stanowe (np. wykonywanie kodu w piaskownicy), użyj parametru environment_id z ukończonej interakcji, aby kontynuować w tym samym środowisku. Dzięki temu agent będzie mógł kontynuować pracę od miejsca, w którym ją przerwał, zachowując wszystkie pliki i stan.

Python

import time
from google import genai

client = genai.Client()

# First turn: run a task in the background
interaction = client.interactions.create(
    agent="antigravity-preview-05-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-05-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)

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

// First turn: run a task in the background
let interaction = await client.interactions.create({
    agent: "antigravity-preview-05-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-05-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);

REST

# 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-05-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-05-2026\",
      \"input\": \"Fix any failing tests and re-run them.\",
      \"previous_interaction_id\": \"$INTERACTION_ID\",
      \"environment\": \"$ENVIRONMENT_ID\",
      \"background\": true
  }"

Środowiska

Każde wywołanie tworzy lub ponownie wykorzystuje piaskownicę Linux. Parametr environment może przyjmować 3 formy:

Pozycja Opis
"remote" Udostępnij nową piaskownicę z ustawieniami domyślnymi.
"env_abc123" Ponownie użyj istniejącego środowiska według identyfikatora, zachowując wszystkie pliki i stan.
{...} Pełna konfiguracja EnvironmentConfig ze źródłami niestandardowymi i regułami sieciowymi.

Szczegółowe informacje o źródłach (Git, GCS, w tekście), sieci, cyklu życia i limitach zasobów znajdziesz w artykule Środowiska.

Dostępność i ceny

Agent Antigravity jest dostępny w wersji testowej przez Interactions API w Google AI Studio i Gemini API.

Ceny są oparte na modelu płatności według wykorzystania i zależą od tokenów bazowego modelu Gemini oraz narzędzi używanych przez agenta. W przeciwieństwie do standardowego żądania czatu, które generuje pojedyncze dane wyjściowe, interakcja Antigravity to przepływ pracy agenta. Pojedyncze żądanie wywołuje autonomiczną pętlę rozumowania, wykonywania narzędzi, uruchamiania kodu i zarządzania plikami.

Szacunkowy koszt

Koszty zależą od złożoności zadania. Agent autonomicznie określa, ile wywołań narzędzi, wykonań kodu i operacji na plikach jest potrzebnych. Poniższe szacunki są oparte na uruchomieniach.

Kategoria zadania Tokeny wejściowe Tokeny wyjściowe Standardowa cena
Badanie i synteza informacji 100 tys.–500 tys. 10 tys.–40 tys. 0,30–1,00 USD
Generowanie dokumentów i treści 100 tys.–500 tys. 15 tys.–50 tys. 0,30–1,30 USD
Projektowanie procesów i systemów 100 tys.–400 tys. 10 tys.–30 tys. 0,25–0,80 USD
Przetwarzanie i analiza danych 300 tys.–3 mln 30 tys.–150 tys. 0,70–3,25 USD

Zazwyczaj 50–70% tokenów wejściowych jest buforowanych. Złożone przepływy pracy agenta z wieloma wywołaniami narzędzi mogą zgromadzić 3–5 mln tokenów w jednej interakcji, a koszty mogą wynieść do ok. 5 USD.

W okresie korzystania z wersji testowej nie są naliczane opłaty za obliczenia w środowisku (procesor, pamięć, wykonywanie w piaskownicy).

Ograniczenia

  • Stan wersji testowej: agent Antigravity i Interactions API. Funkcje i schematy mogą ulec zmianie.
  • Nieobsługiwana konfiguracja generowania: te parametry nie są obsługiwane i zwracają błąd 400: temperature, top_p, top_k, stop_sequences, max_output_tokens.
  • Uporządkowane dane wyjściowe: agent Antigravity nie obsługuje uporządkowanych danych wyjściowych.
  • Niedostępne narzędzia: narzędzia file_search, computer_use i google_maps nie są jeszcze obsługiwane.
  • Ograniczenia zdalnego serwera MCP: transport zdarzeń wysyłanych przez serwer (SSE) nie jest obsługiwany (użyj strumieniowego protokołu HTTP). Ponadto nazwa serwera name musi składać się wyłącznie z małych liter i znaków alfanumerycznych (użycie wielkich liter powoduje ogólny błąd 400 Bad Request).
  • Narzędzie systemu plików: obecnie nie ma narzędzia systemu plików. Jest ono częścią parametru environment.
  • Wymaganie dotyczące przechowywania: wykonywanie agenta za pomocą parametru background=True wymaga ustawienia store=True.
  • Wywoływanie funkcji tylko w trybie stanowym: wywoływanie funkcji jest obsługiwane tylko w trybie stanowym. Aby kontynuować etap, musisz użyć parametru previous_interaction_id. Ręczne odtwarzanie historii (tryb bezstanowy) nie jest obsługiwane.
  • Nieobsługiwane typy multimodalne. Obecnie nie obsługujemy danych wejściowych audio, wideo i dokumentów. Dozwolone są tylko tekst i obraz.

Co dalej?