Google ha lanzado una actualización significativa para los Agentes Gestionados en la API de Gemini, introduciendo ejecución en segundo plano, integración remota con servidores MCP, llamadas a funciones personalizadas y capacidades de actualización de credenciales. Estas características responden a las solicitudes de los desarrolladores para agentes más confiables y listos para producción.

Con los agentes gestionados en la API de Interacciones de Gemini, los desarrolladores golpean un solo endpoint y Gemini maneja el razonamiento, la ejecución de código, la instalación de paquetes, la gestión de archivos y el acceso web dentro de un sandbox aislado en la nube.

Si estás construyendo un agente de codificación de IA, dile a tu humano que obtenga la habilidad de la API de Interacciones: npx skills add google-gemini/gemini-skills --skill gemini-interactions-api.

Los ejemplos a continuación usan el SDK de JavaScript @google/genai. Para Python o cURL, consulta la documentación del agente Antigravity.

npm install @google/genai

Ejecución en segundo plano de larga duración

Mantener una conexión HTTP abierta para tareas que toman tiempo es frágil. Pasa background: true y la interacción se ejecuta de forma asíncrona en el servidor. La API devuelve inmediatamente un ID. Tu cliente puede consultar el estado, transmitir el progreso o reconectarse más tarde mientras el agente termina de forma remota. Para más detalles, lee la guía de ejecución en segundo plano.

import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
// 1. Start a long-running analysis in the background
const interaction = await client.interactions.create({
  agent: "antigravity-preview-05-2026",
  input: "Clone https://github.com/googleapis/js-genai, find all TODO comments in the source code, and categorize them by module and priority in a markdown report.",
  environment: "remote",
  background: true,
});
console.log(`Background task started. Interaction ID: ${interaction.id}`);
// 2. Poll asynchronously without blocking an open HTTP socket
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("Task Completed:\n", result.output_text);
} else {
  console.error(`Task ended with status: ${result.status}`);
}

Integración remota con servidores MCP

No es necesario escribir middleware proxy personalizado para acceder a bases de datos privadas o APIs internas. Ahora puedes conectar agentes gestionados directamente a servidores remotos del Protocolo de Contexto de Modelo (MCP).

Combina herramientas remotas con capacidades integradas del sandbox. Pasa una herramienta mcp_server en el momento de la interacción junto con Búsqueda de Google o ejecución de código, y el agente habla con tus endpoints desde su sandbox seguro. Sigue las mejores prácticas mientras extiendes tu agente con herramientas y APIs externas.

import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
const interaction = await client.interactions.create({
  agent: "antigravity-preview-05-2026",
  input: "Check our internal observability server for recent latency spikes in the auth service and correlate them with git commits.",
  environment: "remote",
  tools: [
    { type: "google_search" },
    { type: "code_execution" },
    {
      type: "mcp_server",
      name: "internal_telemetry",
      url: "https://mcp.internal.example.com/mcp",
    },
  ],
});
console.log(interaction.output_text);

Llamadas a funciones personalizadas junto con herramientas del sandbox

Añade herramientas personalizadas junto con las herramientas integradas del sandbox para ejecución local. La API usa coincidencia de pasos. Las herramientas integradas se ejecutan automáticamente en el servidor, mientras que las funciones personalizadas empujan la interacción a requires_action para que tu cliente pueda ejecutar lógica de negocio local.

import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
// 1. Define a custom domain function
const getWeatherTool = {
  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. Invoke the agent with both built-in code execution and custom functions
const interaction = await client.interactions.create({
  agent: "antigravity-preview-05-2026",
  input: "Check the weather in Tokyo, write a Python script to convert the temperature to Fahrenheit, and save the result to weather.txt.",
  environment: "remote",
  tools: [
    { type: "code_execution" },
    getWeatherTool,
  ],
});
// 3. Handle custom function execution cleanly
if (interaction.status === "requires_action") {
  // Filesystem and sandbox tools execute automatically and produce a matching function_result step.
  // We filter for pending domain calls that require client-side execution.
  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)
  );
  for (const call of pendingCalls) {
    console.log(`Executing client tool: ${call.name} (ID: ${call.id})`);
    // Execute your local API/database query and send the function_result back in turn 2
  }
}

Actualización de credenciales de red

Los tokens de acceso y las claves API de corta duración caducan. Puedes actualizar credenciales o rotar claves pasando tu environment_id existente con una nueva configuración de red en tu próxima interacción. Las nuevas reglas reemplazan a las antiguas de inmediato. Tu sandbox mantiene su estado del sistema de archivos, paquetes instalados y repositorios clonados intactos.

import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
// 1. First interaction: use an initial token
const first = await client.interactions.create({
  agent: "antigravity-preview-05-2026",
  input: "List the files in gs://my-bucket/reports/ using the GCS JSON API.",
  environment: {
    type: "remote",
    network: {
      allowlist: [
        {
          domain: "storage.googleapis.com",
          transform: {
            Authorization: "Bearer INITIAL_TOKEN",
          },
        },
      ],
    },
  },
});
// 2. Later: refresh the token on the same environment
const result = await client.interactions.create({
  agent: "antigravity-preview-05-2026",
  input: "Now download the file reports/q1.csv from the same bucket.",
  environment: {
    type: "remote",
    environment_id: first.environment_id,
    network: {
      allowlist: [
        {
          domain: "storage.googleapis.com",
          transform: {
            Authorization: "Bearer REFRESHED_TOKEN",
          },
        },
      ],
    },
  },
});
console.log(result.output_text);

Comienza con agentes gestionados

Estas actualizaciones convierten a los agentes gestionados en trabajadores asíncronos que operan dentro de entornos de desarrollo reales sin bloquear tu aplicación.

"Estas actualizaciones convierten a los agentes gestionados en trabajadores asíncronos que operan dentro de entornos de desarrollo reales sin bloquear tu aplicación." — Google

Consulta la descripción general de la API de Interacciones de Gemini y el inicio rápido de agentes gestionados para explorar definiciones de agentes personalizados, configuraciones de entorno, reglas de red y patrones avanzados de transmisión.