Antigravity ajanı, Gemini API'de genel amaçlı bir yönetilen ajandır. Tek bir API çağrısıyla, Google tarafından barındırılan kendi güvenli Linux korumalı alanınızda akıl yürüten, kod çalıştıran, dosyaları yöneten ve web'de gezinen bir temsilciye sahip olursunuz.
Gemini 3.8 Flash ile oluşturulmuştur ve Antigravity IDE ile aynı donanımı kullanır. Temel Gemini modelini agent_config kullanarak yapılandırabilirsiniz. Interactions API ve Google AI Studio üzerinden kullanılabilir.
Python
from google import genai
client = genai.Client()
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)
JavaScript
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
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);
Java
import com.google.genai.Client;
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 = new Client();
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(""));
Go
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.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)
}
}
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-09-2026",
"input": "Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
"environment": "remote"
}'
Özellikler
Her çağrı, bir Linux korumalı alanı sağlayabilir ve araç kullanım döngüsü başlatabilir. Ajan; plan yapar, harekete geçer, sonuçları gözlemler ve görev tamamlanana kadar tekrarlar.
- Kod yürütme: Bash, Python ve Node.js komutlarını çalıştırın. Paketleri yükleyin, testleri çalıştırın ve uygulamalar oluşturun.
- Dosya yönetimi: Korumalı alandaki dosyaları okuma, yazma, düzenleme, arama ve listeleme. Dosyalar, etkileşimler arasında korunur.
- Web erişimi: Veriler için Google Arama ve URL getirme.
- Bağlam sıkıştırma: Bağlamı kaybetmeden veya jeton sınırlarına ulaşmadan uzun süren, çok turlu oturumları desteklemek için otomatik bağlam sıkıştırma (~135 bin jetonda tetiklenir).
Çok turlu kullanım ve yayın için Hızlı Başlangıç bölümüne bakın.
Desteklenen araçlar
Ajan varsayılan olarak code_execution, google_search ve url_context verilerine erişebilir. environment parametresini belirttiğinizde dosya sistemi araçları otomatik olarak etkinleştirilir. Temsilciyi kendi API'lerinize ve araçlarınıza bağlamak için özel işlevler de tanımlayabilirsiniz. tools parametresini yalnızca varsayılan grubu özelleştirirken veya kısıtlarken ya da özel işlevler eklerken belirtmeniz gerekir.
| Araç | Tür değeri | Açıklama |
|---|---|---|
| Kod Yürütme | code_execution |
stdout/stderr yakalama ile kabuk komutlarını (bash, Python, Node) çalıştırma. |
| Google Arama | google_search |
Herkese açık web'de arama yapma |
| URL Bağlamı | url_context |
Web sayfalarını getirip okuma. |
| Dosya sistemi | (environment üzerinden etkinleştirilir) |
Sandbox'ta dosyaları okuma, yazma, düzenleme, arama ve listeleme environment ayarını yaptığınızda sistem bu araçları otomatik olarak etkinleştirir. |
| Özel İşlevler | function |
Temsilcinin yürütme isteğinde bulunabileceği özel işlevler tanımlayın. İşlev çağırma başlıklı makaleyi inceleyin. |
| Uzak MCP Sunucusu | mcp_server |
Harici Model Context Protocol (MCP) sunucularını araç olarak kaydetme MCP sunucuları sayfasına göz atın. |
Eşzamanlı kancaları kullanarak code_execution ve filesystem araçlarının yürütülmesini doğrudan uzak korumalı alanda kesintiye uğratabilir ve doğrulayabilirsiniz.
Temsilciyi belirli araçlarla sınırlamak için yalnızca ihtiyacınız olan araçları iletin:
Python
from google import genai
client = genai.Client()
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)
JavaScript
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
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);
Java
import com.google.genai.Client;
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 = new Client();
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(""));
Go
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.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)
}
}
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-09-2026",
"input": "Search for the latest AI research papers on reasoning and summarize them.",
"environment": "remote",
"tools": [
{"type": "google_search"},
{"type": "url_context"}
]
}'
Çok formatlı giriş
Antigravity ajanı, çok formatlı girişleri destekler. Şu anda yalnızca text ve image girişleri desteklenmektedir. Resimler, satır içi base64 kodlu dizeler (data) olarak sağlanmalıdır.
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-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",
)
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-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 });
Java
import com.google.genai.Client;
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 = new Client();
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(""));
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, nil)
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)
}
}
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-09-2026\",
\"input\": [
{\"type\": \"text\", \"text\": \"Analyze this chart and summarize the trends.\"},
{
\"type\": \"image\",
\"mime_type\": \"image/png\",
\"data\": \"$BASE64_IMAGE\"
}
],
\"environment\": \"remote\"
}"
İşlev çağırma
İşlev çağırma, Antigravity temsilcisinin çağırabileceği özel araçlar tanımlayarak temsilciyi harici API'lere ve veritabanlarına bağlamanıza olanak tanır. Genel kavramlar için Gemini API ile işlev çağrısı başlıklı makaleyi inceleyin.
Aşağıdaki örnekte 2 dönüşlü bir etkileşim gösterilmektedir. Temsilci önce özel bir get_weather işlev çağrısı ister, istemci bunu yürütür ve sonucu ikinci sırada döndürür.
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-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}")
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-09-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_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];
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-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}`);
}
Java
import com.google.genai.Client;
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 = new Client();
// 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));
}
Go
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
// 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)
}
}
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-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\"
}
}
]
}"
MCP sunucuları
Uzak Model Context Protocol (MCP) sunucularını kaydederek Antigravity ajanını harici araçlara bağlayabilirsiniz. Temsilci, akış yapılabilir HTTP üzerinden uzak MCP sunucularını destekler.
Bir MCP sunucusunu kaydederken tools dizisinde aşağıdaki alanları belirtmeniz gerekir:
| Alan | Tür | Zorunlu | Açıklama |
|---|---|---|---|
type |
dize | Evet | "mcp_server" olmalıdır. |
name |
dize | Evet | Sunucu için benzersiz tanımlayıcı. Yalnızca küçük harf ve alfanümerik karakterlerden oluşmalıdır (^[a-z0-9_-]+$ ile eşleşmelidir). |
url |
dize | Evet | Uzak MCP sunucusunun uç nokta URL'si. |
headers |
nesne | Hayır | İsteklerle gönderilen özel üstbilgiler (ör. kimlik doğrulama). |
allowed_tools |
dizi | Hayır | Yürütülmesine izin verilen araç adlarının listesi. Atlanırsa tüm araçlara izin verilir. |
Python
from google import genai
client = genai.Client()
# 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)
JavaScript
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
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);
Java
import com.google.genai.Client;
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 = new Client();
// 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(""));
Go
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
// 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)
}
}
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-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"
}]
}'
Model seçimi
antigravity-preview-09-2026 için varsayılan model Gemini 3.8 Flash (gemini-3.8-flash) olur. agent_config öğesini atlarsanız aracı varsayılan olarak gemini-3.8-flash modelini kullanır.
Hızı, maliyeti veya muhakeme yeteneğini optimize etmek için agent_config kullanarak temel Gemini modelini yapılandırabilirsiniz. Örneğin, karmaşık yazılım mühendisliği ve akıl yürütme görevleri için model parametresini Gemini 4 Argon (gemini-4-argon) olarak ayarlayın:
Python
from google import genai
client = genai.Client()
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-argon",
},
)
print(interaction.output_text)
JavaScript
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
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-argon",
},
}, { timeout: 300000 });
console.log(interaction.output_text);
Java
import com.google.genai.Client;
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 = new Client();
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-argon")
.build()
)
.build();
Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
System.out.println(interaction.outputText().orElse(""));
Go
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.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-argon"),
})),
}),
})
if err != nil {
log.Fatal(err)
}
if res.Interaction.OutputText != nil {
fmt.Println(*res.Interaction.OutputText)
}
}
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-09-2026",
"input": "Summarize the key differences between functional and object-oriented programming.",
"environment": "remote",
"agent_config": {
"type": "antigravity",
"model": "gemini-4-argon"
}
}'
agent_config.model için desteklenen değerler şunlardır:
| Model | agent_config.model cinsinden değer |
Açıklama |
|---|---|---|
| Gemini 3.8 Flash (varsayılan) | gemini-3.8-flash |
Akıl yürütme, kodlama ve araç kullanımı için varsayılan dengeli model. |
| Gemini 4 Argon | gemini-4-argon |
Karmaşık yazılım mühendisliği, derin problem çözme ve uzun vadeli temsilci görevleri için öncü akıl yürütme modeli. |
| Gemini 3.6 Flash | gemini-3.6-flash |
Genel ajan tabanlı iş akışları için dengeli Flash modeli. |
| Gemini 3.5 Flash-Lite | gemini-3.5-flash-lite |
Düşük gecikme süresi ve maliyet açısından hassas görevler için optimize edilmiş hafif model. |
agents.create ile yönetilen bir temsilci oluştururken base_agent ve agent_config değerlerini ileterek modeli aynı şekilde yapılandırırsınız. agents.create ile oluşturulan yönetilen bir aracı için etkileşim sırasında modeli geçersiz kılamayacağınızı unutmayın. Model, temsilci oluşturulurken belirlenen ayarlarla kilitlenir. Bu sayede, araç çağrısı davranışının öngörülebilir olması, tutarlı hata ayıklama ve güvenlik sınırlarına uyulması sağlanır.
Temsilciyi özelleştirme
Antigravity ajanını talimatlarını, araçlarını ve ortamını özelleştirerek genişletebilirsiniz. Temsilci, özelleştirme için dosya sistemine özgü bir yaklaşımı destekler: .agents/skills/ altındaki talimatlar ve beceriler için AGENTS.md gibi dosyaları doğrudan korumalı alana bağlayabilir veya etkileşim sırasında yapılandırmayı satır içi olarak iletebilirsiniz. Yapılandırmanızı satır içi olarak yineleyebilir ve hazır olduğunuzda yönetilen bir temsilci olarak kaydedebilirsiniz.
Özel ajan oluşturma hakkında ayrıntılı bilgi için Yönetilen Ajanlar Oluşturma başlıklı makaleyi inceleyin.
Arka planda yürütme
Çok adımlı akıl yürütme, kod yürütme veya dosya işlemleri içeren aracı görevlerinin tamamlanması birkaç dakika sürebilir. Etkileşimi eşzamansız olarak çalıştırmak için background=True kullanın. API, durum completed veya failed olana kadar yokladığınız bir etkileşim kimliğiyle hemen yanıt verir.
Python
import time
from google import genai
client = genai.Client()
# 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}")
JavaScript
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
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}`);
}
Java
import com.google.genai.Client;
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 = new Client();
// 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));
}
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, nil)
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)
}
}
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-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"
Arka planda yürütme için varsayılan olarak store=True gerekir. Arka planda yürütme sırasında anlık ilerleme durumu güncellemeleri için Arka planda etkileşimleri yayınlama başlıklı makaleyi inceleyin.
cancel yöntemini kullanarak devam eden bir arka plan etkileşimini iptal edebilirsiniz.
Python
client.interactions.cancel(id="INTERACTION_ID")
JavaScript
await client.interactions.cancel("INTERACTION_ID");
Java
import com.google.genai.Client;
Client client = new Client();
client.interactions.cancel("INTERACTION_ID");
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, nil)
if err != nil {
log.Fatal(err)
}
_, err = client.Interactions.Cancel(ctx, operations.CancelInteractionByIDRequest{
ID: "INTERACTION_ID",
})
if err != nil {
log.Fatal(err)
}
}
REST
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions/INTERACTION_ID:cancel" \
-H "x-goog-api-key: $GEMINI_API_KEY"
Arka planda yürütme ile çok turlu görüşme
Arka plandaki bir etkileşim durum bilgisi olan araçları (ör. sanal ortamda kod yürütme) içerdiğinde aynı ortamda devam etmek için tamamlanan etkileşimdeki environment_id simgesini kullanın. Bu sayede temsilci, tüm dosyalar ve durumlar bozulmadan kaldığı yerden devam eder.
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-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)
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-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);
Java
import com.google.genai.Client;
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 = new Client();
// 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(""));
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, nil)
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)
}
}
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-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
}"
Ortam
Her çağrı bir Linux korumalı alanı oluşturur veya mevcut bir alanı yeniden kullanır. environment parametresi üç biçimde kullanılır:
| Form | Açıklama |
|---|---|
"remote" |
Varsayılan ayarlarla yeni bir korumalı alan oluşturun. |
"env_abc123" |
Tüm dosyaları ve durumu koruyarak mevcut bir ortamı kimliğe göre yeniden kullanın. |
{...} |
Özel kaynaklar ve ağ kurallarıyla tam EnvironmentConfig. |
Kaynaklar (Git, GCS, satır içi), ağ, yaşam döngüsü ve kaynak sınırları hakkında ayrıntılı bilgi için Ortamlar başlıklı makaleyi inceleyin.
Tetikleyiciler
Tetikleyiciler, bir temsilciyi cron planına göre otomatik olarak çalışacak şekilde planlamanıza olanak tanır. Tetikleyici; bir temsilciyi, ortamı, istemi ve programı manuel müdahale olmadan tetiklenen kalıcı bir kaynakta birleştirir. Her yürütme aynı ortamı yeniden kullandığından bir çalıştırmada oluşturulan dosyalar kalıcı olur ve bir sonraki çalıştırmada görünür.
Tetikleyici oluştur
Cron programı, saat dilimi ve etkileşim yapılandırmasını belirterek tetikleyici oluşturun. Tetikleyici active durumunda başlar ve bir sonraki eşleşen cron zamanında etkinleşir. Sonraki çağrılarda tetikleyiciyi yönetmek için döndürülen id değerini kaydedin.
Tetikleyici, planlanmış bir zamanda katılımsız olarak çalıştığından satır içi jeton yerine depolanmış bir kimlik bilgisine referans verin. Çıkış proxy'si her çalıştırmada bu gizli anahtarı çözer ve tetikleyiciye dokunmadan gizli anahtarı rotasyona tabi tutarsınız. Satır içi transform kuralları burada da çalışır. Değer her değiştiğinde tetikleyiciyi güncellemeniz yeterlidir.
Python
from google import genai
client = genai.Client()
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}")
JavaScript
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
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}`);
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));
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)
}
REST
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"}
]
}
}
}
}'
CreateTrigger isteği aşağıdaki alanları kabul eder:
| Alan | Tür | Zorunlu | Açıklama |
|---|---|---|---|
schedule |
dize | Evet | Cron ifadesi (ör. saatte bir için 0 * * * *, hafta içi sabahları için 0 9 * * 1-5). |
time_zone |
dize | Evet | IANA saat dilimi (ör. UTC, America/Argentina/Buenos_Aires). |
display_name |
dize | Hayır | Tetikleyicinin kullanıcılar tarafından okunabilen adı. |
max_consecutive_failures |
tam sayı | Hayır | Tetikleyici otomatik olarak duraklatılmadan önce izin verilen maksimum hata sayısı. Varsayılan: 5. |
execution_timeout_seconds |
tam sayı | Hayır | Yürütme başına saniye cinsinden zaman aşımı. Varsayılan: 600. |
interaction |
nesne | Evet | Temsilciyi, girişi, araçları ve ortamı tanımlayan bir CreateInteractionRequest. |
Yanıtta aşağıdaki anahtar alanlar bulunur:
| Alan | Tür | Açıklama |
|---|---|---|
id |
dize | Tetikleyicinin benzersiz tanımlayıcısı. Bu değeri sonraki tüm işlemlerde kullanın. |
status |
dize | Mevcut durum: active, paused veya disabled. |
next_run_time |
dize | Sonraki planlanmış yürütmenin ISO 8601 zaman damgası. |
consecutive_failure_count |
tam sayı | Son başarılı yürütmeden sonraki başarısız yürütmelerin sayısı. |
Tetikleyicileri listeleme
Projenizle ilişkili tüm tetikleyicileri alın.
Python
triggers = client.triggers.list()
for trigger in triggers.triggers:
print(f"{trigger.id}: {trigger.display_name} ({trigger.status})")
JavaScript
const triggers = await client.triggers.list();
for (const trigger of triggers.triggers) {
console.log(`${trigger.id}: ${trigger.display_name} (${trigger.status})`);
}
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) + ")");
}
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)
}
}
}
REST
curl -X GET "https://generativelanguage.googleapis.com/v1beta/triggers" \
-H "x-goog-api-key: $GEMINI_API_KEY"
Tetikleyici alma
Tek bir tetikleyicinin tam yapılandırmasını ve mevcut durumunu getirir.
Python
trigger = client.triggers.get(id="TRIGGER_ID")
print(f"Schedule: {trigger.schedule}")
print(f"Next run: {trigger.next_run_time}")
JavaScript
const trigger = await client.triggers.get("TRIGGER_ID");
console.log(`Schedule: ${trigger.schedule}`);
console.log(`Next run: ${trigger.next_run_time}`);
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));
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)
}
REST
curl -X GET "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID" \
-H "x-goog-api-key: $GEMINI_API_KEY"
Duraklatma ve devam ettirme
Programlanmış yürütmeleri durdurmak için tetikleyiciyi duraklatabilir ve programı yeniden etkinleştirmek için devam ettirebilirsiniz. Duraklatma, manuel yürütmeleri etkilemez.
Python
# Pause
client.triggers.update(id="TRIGGER_ID", status="paused")
# Resume
client.triggers.update(id="TRIGGER_ID", status="active")
JavaScript
// Pause
await client.triggers.update("TRIGGER_ID", { status: "paused" });
// Resume
await client.triggers.update("TRIGGER_ID", { status: "active" });
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());
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)
}
}
REST
# 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"}'
Tetikleyici silme
Tetikleyiciyi kalıcı olarak kaldırma Geçmiş yürütme geçmişi silinmez.
Python
client.triggers.delete(id="TRIGGER_ID")
JavaScript
await client.triggers.delete("TRIGGER_ID");
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");
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)
}
}
REST
curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID" \
-H "x-goog-api-key: $GEMINI_API_KEY"
Tetikleyiciyi hemen çalıştırma
Bir sonraki planlı zamanı beklemeden, isteğe bağlı olarak bir tetikleyiciyi etkinleştirin. Bu özellik, tetikleyici duraklatılmış olsa bile çalışır.
Python
client.triggers.run(trigger_id="TRIGGER_ID")
JavaScript
await client.triggers.run("TRIGGER_ID");
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");
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)
}
}
REST
curl -X POST "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID/executions" \
-H "x-goog-api-key: $GEMINI_API_KEY"
Yürütmeleri listeleme
Tetikleyicinin yürütme geçmişini görüntüleme Her yürütme işleminde bir status, zaman damgaları, tam etkileşim çıkışını almak için kullanabileceğiniz bir interaction_id ve tüm çalıştırmaların aynı korumalı alanı paylaştığını onaylayan bir environment_id bulunur.
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)
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);
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(""));
}
}
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)
}
}
}
}
}
REST
curl -X GET "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID/executions" \
-H "x-goog-api-key: $GEMINI_API_KEY"
Kullanılabilirlik ve fiyatlandırma
Antigravity aracısı, Google AI Studio'daki Interactions API ve hem ücretsiz katman hem de ücretli katman projeleri için Gemini API aracılığıyla önizleme sürümünde kullanılabilir.
Fiyatlandırma, temel Gemini modeli jetonlarına ve temsilcinin kullandığı araçlara göre kullandıkça öde modeline dayanır. Tek bir çıkış üreten standart bir sohbet isteğinin aksine, Antigravity etkileşimi bir temsilci iş akışıdır. Tek bir istek; akıl yürütme, araç çalıştırma, kod yürütme ve dosya yönetiminden oluşan otonom bir döngüyü tetikler. Ücretsiz katman projeleri, ücretsiz sıklık sınırlaması ve kullanım kotası içerir.
Antigravity etkileşimleri, çok aşamalı otonom döngüler çalıştırır ve önemli miktarda jeton tüketebilir. Jeton kullanımını sınırlamak için isteğinizde bütçe kontrolleri ayarlayın. Ayrıca SSE akışı ile ilerleme durumunu anlık olarak izleyebilir veya çalışan istekleri iptal edebilirsiniz.
Bütçe kontrolleri
Model seçimine ek olarak, bir etkileşimin kullanabileceği toplam parça sayısını (giriş + çıkış + düşünme) sınırlamak için agent_config içinde max_total_tokens değerini ("type": "antigravity" ile) ayarlayın.
Önbelleğe alınmış jetonlar bu sınıra dahil edilmez. Temsilci sınıra ulaştığında etkileşim durur ve status: "incomplete" ile geri döner. Sınır, en iyi çaba ilkesine göre uygulanır:
Temsilcinin adımlar arasında bütçeyi ne zaman kontrol ettiğine bağlı olarak gerçek kullanım, sınırı biraz aşabilir.
agent_config, agent ve input ile birlikte etkileşim isteğinde bütçeyi ayarlayın.
Python
from google import genai
client = genai.Client()
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}")
JavaScript
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
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}`);
Java
import com.google.genai.Client;
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 = new Client();
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)));
Go
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
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)
}
}
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-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"
}
]
}
}'
Tamamlanmamış bir etkileşimi devam ettirme
Bir etkileşim status: "incomplete" döndürdüğünde temsilcinin çalışması ve bağlamı korunur. Kaldığı yerden devam etmek için orijinal etkileşime id ve environment_id referans veren yeni bir etkileşim gönderin. Yeni etkileşimin kendi max_total_tokens bütçesi olur.
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}")
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}`);
Java
import com.google.genai.Client;
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 = new Client();
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));
Go
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
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)
}
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-09-2026",
"input": "continue",
"previous_interaction_id": "INTERACTION_ID",
"environment": "ENVIRONMENT_ID",
"agent_config": {
"type": "antigravity",
"max_total_tokens": 50000
}
}'
Tahmini maliyetler
Maliyetler, görevin karmaşıklığına göre değişir. Temsilci; kaç tane araç çağrısı, kod yürütme ve dosya işlemi gerektiğini otonom olarak belirler. Aşağıdaki tahminler, çalıştırmalara dayanmaktadır.
| Görev kategorisi | Giriş jetonu sayısı | Çıkış jetonu sayısı | Normal maliyet |
|---|---|---|---|
| Araştırma ve bilgi sentezi | 100.000-500.000 | 10.000-40.000 | 0,30-1,00 ABD doları |
| Doküman ve içerik oluşturma | 100.000-500.000 | 15.000-50.000 | 0,30-1,30 ABD doları |
| Süreç ve sistem tasarımı | 100.000-400.000 | 10.000-30.000 | 0,25-0,80 ABD doları |
| Veri işleme ve analiz | 300 bin - 3 milyon | 30.000-150.000 | 0,70-3,25 ABD doları |
Giriş jetonlarının% 50-70'i genellikle önbelleğe alınır. Çok sayıda araç çağrısı içeren karmaşık temsilci iş akışları, tek bir etkileşimde 3-5 milyon jeton biriktirebilir ve maliyeti yaklaşık 5 ABD dolarına kadar çıkabilir.
Önizleme döneminde ortam bilişimi (CPU, bellek, korumalı alan yürütme) için fatura kesilmez.
Sınırlamalar
- Önizleme durumu: Antigravity ajanı ve Interactions API'si. Özellikler ve şemalar değişebilir.
- Desteklenmeyen içerik üretme yapılandırması: Aşağıdaki parametreler desteklenmez ve 400 hatası döndürür:
temperature,top_p,top_k,stop_sequences,max_output_tokens. - Yapılandırılmış çıkış: Antigravity aracısı, yapılandırılmış çıkışları desteklemez.
- Kullanılamayan araçlar:
file_search,computer_usevegoogle_mapshenüz desteklenmiyor. - Uzak MCP sınırlamaları: Server-Sent Events (SSE) aktarımı desteklenmez (Streamable HTTP kullanın). Ayrıca, sunucu
namekesinlikle küçük harf ve alfasayısal olmalıdır (büyük harf kullanılması genel bir400 Bad Requesthatasını tetikler). - Dosya sistemi aracı: Şu anda dosya sistemi aracı yoktur. Bu,
environment'nın bir parçasıdır. - Mağaza şartı:
background=Truekullanılarak temsilci yürütme içinstore=Truegerekir. - Yalnızca durum bilgisi olan işlev çağrısı: İşlev çağrısı yalnızca durum bilgisi olan modda desteklenir. Sıraya devam etmek için
previous_interaction_idkullanmanız gerekir. Geçmişi manuel olarak yeniden oluşturma (durumsuz mod) desteklenmez. - Desteklenmeyen çok formatlı türler Ses, video ve belge girişleri şu anda desteklenmemektedir. Yalnızca metin ve resme izin verilir.
Sırada ne var?
- Hızlı başlangıç: Çok adımlı sohbetler ve yayın.
- Özel temsilciler oluşturma: özel talimatlar, beceriler ve temsilcileri kaydetme.
- Ortamlar: korumalı alan yapılandırması, kaynaklar, ağ.
- Kancalar: Korumalı alanda güvenlik kapılarını ve yan etki doğrulamasını zorunlu kılar.
- Deep Research aracısı: Uzun araştırma görevleri.
- Interactions API: Temel API.