Gemini’s Managed Agents Now Run on Free Tier — But the Budget Controls Are Why Devs Should Care

Gemini’s Managed Agents Now Run on Free Tier Updates

Most AI updates focus on new models or benchmarks. However, Gemini’s managed agents now run on free tier with practical infrastructure improvements. Google addressed three specific developer pain points regarding cost, scheduling, and access.

These changes make the Gemini Interactions API more viable for production. The updates include free tier access, token budget guardrails, and cron-based triggers. Together, they form a coherent infrastructure play for engineers building agentic tooling.

Understanding Managed Agents in the Gemini API

First, we must define what managed agents actually do. Calling the Gemini Interactions API hands a task to a cloud-hosted agent. This Antigravity agent autonomously handles reasoning, code execution, and file management in an isolated sandbox.

You send a single request, and the agent runs a multi-step loop server-side. Files persist between interactions without local infrastructure. Consequently, this model differs significantly from standard LLM calls.

A single interaction can spawn dozens of tool calls. Therefore, cost control and automation features carry much higher stakes here than in typical API contexts.

Free Tier Access Lowers Barriers

The most straightforward update is free tier availability. You can now use managed agents with an API key tied to a free project. No active billing is required for exploration.

Interactions under the free tier run under specific rate limits. Previously, testing autonomous agents required a billing-enabled project. This change lowers the friction for individual developers evaluating the platform.

However, expect meaningful constraints on throughput. High-volume production workloads still require billing-enabled projects. Yet, for understanding complex tasks, the free tier makes experimentation genuinely accessible.

Budget Controls Solve Runaway Token Costs

The addition of max_total_tokens inside agent_config is technically significant. This parameter caps total tokens for a single interaction. When the limit hits, the agent stops cleanly rather than running up a bill.

This directly addresses the tokenmaxxing problem where agents consume unexpected resources. A hard cap provides a simple primitive for production reliability. Furthermore, incomplete interactions preserve their environment state.

You can resume exactly where the agent left off by passing the previous interaction ID. Thus, budget controls act as checkpoints rather than kill switches. This enables safe deployment in cost-sensitive environments.

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

const client = new GoogleGenAI({});

// Start a repository audit capped at 10,000 tokens
const interaction = await client.interactions.create({
  agent: "antigravity-preview-05-2026",
  input: "Clone https://github.com/google/guava, audit all modules for deprecated classes, and generate a migration report at /workspace/migration_audit.md.",
  agent_config: {
    type: "antigravity",
    max_total_tokens: 10000,
  },
  environment: "remote",
});

console.log(`Status: ${interaction.status}`);
console.log(`Tokens used: ${interaction.usage?.total_tokens}`);

// Resume if the budget was hit before completion
if (interaction.status === "incomplete") {
  const continuation = await client.interactions.create({
    agent: "antigravity-preview-05-2026",
    input: "continue",
    previous_interaction_id: interaction.id,
    environment: interaction.environment_id,
    agent_config: {
      type: "antigravity",
      max_total_tokens: 10000,
    },
  });
  console.log(`Continuation status: ${continuation.status}`);
}

Scheduled Triggers Enable Recurring Infrastructure

Triggers represent a major architectural shift. They bind an agent, environment, and prompt to a cron schedule. This creates a persistent resource that fires automatically without external scripts.

Each execution reuses the same underlying sandbox environment. Therefore, files and reports from previous runs remain available immediately. This suits tasks like daily issue triage or nightly regression reporting.

Additionally, network allowlists let agents reach specific external domains securely. Scheduled agents can legitimately interact with authenticated services like GitHub APIs. Persistent file state allows the agent to skip previously solved issues efficiently.

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

const client = new GoogleGenAI({});

const trigger = await client.triggers.create({
  schedule: "0 9 * * *", // Every day at 9:00 AM
  time_zone: "America/Los_Angeles",
  display_name: "daily-issue-solver",
  interaction: {
    agent: "antigravity-preview-05-2026",
    input: [
      {
        type: "text",
        text: "Review open PRs for new comments and address feedback. Check for issues labeled 'accepted', skip any tracked in /workspace/solved-issues/, fix the rest, and open PRs. Save reports to /workspace/solved-issues/.",
      },
    ],
    environment: {
      type: "remote",
      network: {
        allowlist: [
          {
            domain: "api.github.com",
            transform: {
              Authorization: "Bearer ghp_example_token",
            },
          },
          { domain: "github.com" },
        ],
      },
    },
  },
});

console.log(`Trigger created: ${trigger.id}`);
console.log(`Next scheduled run: ${trigger.next_run_time}`);

// List past executions
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})`);
}

Fitting Into the Broader Agentic Landscape

Google bets that developers prefer managed infrastructure over self-hosted orchestration. This release tightens that value proposition with essential operational controls. Features like budget caps move managed agents toward reliable deployment.

Competition now focuses on operational properties rather than raw capabilities. While other tools compete on price, Google competes on production readiness. Teams should add max_total_tokens to every production configuration immediately.

Finally, triggers offer a native alternative to external cron systems for recurring tasks. All three features are available now through the Gemini API. Full documentation covers custom definitions and streaming patterns.