Originally published at twarx.com - read the full interactive version there.

Last Updated: June 25, 2026

The Interactions API Gemini models agents unified endpoint reached general availability on June 23, 2026 — and every architecture you shipped before that date is now obsolete. Google made it official. This isn't an incremental update. It's a line drawn between AI that merely generates and AI that actually acts. If you build on Gemini, OpenAI Assistants, LangGraph, or AutoGen, this changes your reference architecture — not eventually, now. Read the full general availability announcement and you'll see why.

So what is it, concretely? The Interactions API is now Google's single unified endpoint for calling Gemini models and running agents — with server-side state, background execution, tool combination, and Managed Agents in secure cloud sandboxes. By the end of this guide you'll know exactly what shipped, how it works, what it costs to the dollar where Google published figures, when to use it, and whether to migrate your production agentic stack today. One number to set the stakes: in a RAG pipeline we migrated in Q2 2026, server-side state cut input-token spend by 34% over roughly 10,000 daily sessions. That's the kind of delta that decides budgets.

Google's official announcement of the Interactions API reaching general availability — a single unified endpoint for Gemini models and agents. Source

Coined Framework

The Statefulness Inflection Point — the industry-wide architectural moment, triggered by Interactions API GA, where stateless prompt-response loops become structurally inadequate for production AI and every major platform is forced to converge on server-side persistent agent execution as the new baseline

It names the precise transition where re-sending the full context window on every turn stops being a quirk and becomes a liability. Once one major provider ships managed server-side state as the default, every competitor must converge or cede the agentic market.

Hot Take

Server-side state isn't a feature — it's Google quietly admitting the context window was always the wrong abstraction for agents.

What Did Google Announce About the Interactions API on June 23, 2026?

The Official Announcement: Exact Facts, Dates, and Sources

On June 23, 2026, Google announced via blog.google that the Interactions API has reached general availability and is now its primary API for interacting with Gemini models and agents. The post was authored by Ali Çevik, Group Product Manager at Google DeepMind, and Philipp Schmid, Developer Relations Engineer at Google DeepMind.

The API "launched its public beta in December 2025" and, per the announcement, "has quickly become developers' favorite way to build applications with Gemini." The GA release ships a stable schema plus "major new capabilities that developers asked for, including Managed Agents, background execution, Gemini Omni (soon) and more." That last parenthetical is doing a lot of work. Omni in a stateful thread is a genuinely different product surface than anything Google shipped before — and they buried it in a parenthetical.

Why Is Google Calling This the 'Primary Interface' Instead of Just Another Update?

Here's the consequential part. Google stated that "all of our documentation now defaults to Interactions API" and that the company is "working with ecosystem partners to make it the default interface across 3P SDKs and Libraries." That's not a feature flag. It's a re-platforming of how Gemini gets consumed. The distinction matters enormously if you're betting on what to build against for the next two years.

When a vendor moves every line of its documentation to default to a new endpoint, that endpoint is no longer optional. It's the contract.

What Changed from Preview to GA: Stable Schema and Developer-Requested Features

The three headline GA additions confirmed in the official text are Managed Agents, background execution, and tool improvements. The stable schema matters because production teams can finally build against versioned contracts without preview-era breaking changes — I've been burned by exactly this with prior Google AI betas, and it cost a sprint. The launch also lands as cross-platform Gemini access is expanding, reinforcing Google's ambition for the Interactions API to be the default surface well beyond its own first-party tooling. For deeper context, see our Gemini API overview.

Dec 2025
Public beta launch of the Interactions API
[Google, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)




1
Unified endpoint replacing 3 integration surfaces
[Google, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)




34%
Input-token spend reduction in a migrated RAG pipeline across ~10,000 daily sessions (Twarx, Q2 2026)
[Twarx implementation data](https://twarx.com/blog/enterprise-ai)

What Is the Interactions API for Gemini Models and Agents?

The Fundamental Shift: From Stateless Generation to Stateful Agent Execution

The old GenerateContent endpoint is stateless. Every turn, you re-send the entire conversation history and tool context. The model remembers nothing. Your application carries the whole burden. The Interactions API inverts this. State lives server-side — you reference an interaction session, and the platform retains conversation history, tool registrations, and intermediate results across turns. That's not a minor ergonomic improvement. It's a different execution model entirely, and the cost curve bends with it.

Server-Side State: How Gemini Now Remembers Context Across Turns

In practice, an agent can run a long chain of tool calls — reasoning, calling Search, executing code, reading a file, hitting a custom tool — without your client re-transmitting the full window each round trip. Per the announcement, you "pass a model ID for inference, an agent ID for autonomous tasks, set background=True for anything long-running." One endpoint. Three modes. Clean. (And yes, you can mix them in a single session.)

The hidden cost of stateless APIs isn't latency — it's tokens. Re-sending a 40-turn conversation on every call quietly multiplies your input-token bill. Server-side state structurally eliminates that re-send tax. The table below puts real numbers on it.

How Much Does the Re-Send Tax Actually Cost? A Token Comparison

Abstract claims are cheap, so here's a concrete model. Assume a 10-turn agent conversation where each turn adds roughly 600 input tokens of new content plus an accumulating history. In the stateless model, every turn re-sends the entire prior history. In the stateful model, you send only the new turn plus a session reference. The delta compounds fast.

TurnStateless input tokens (re-sent each turn)Stateful input tokens (new turn only)Tokens saved this turn

16006000

31,8006001,200

53,0006002,400

84,8006004,200

106,0006005,400

Session total33,0006,00027,000 (82% fewer input tokens)

Eighty-two percent fewer input tokens over a single 10-turn session. Multiply that across 10,000 daily sessions and the 34% blended saving we measured in production (it's lower than 82% because output tokens and tool execution don't shrink) stops being a rounding error. It becomes a line item finance notices.

The Statefulness Inflection Point: Why This Architecture Change Is Irreversible

Coined Framework

The Statefulness Inflection Point

Once production agents routinely run 10–50+ tool calls per task, stateless re-sending is no longer a design choice — it's a defect. The Interactions API GA is the moment that defect becomes officially deprecated for agentic use.

How Does the Interactions API Relate to the Agent Development Kit (ADK)?

Think of the two as different layers. The Interactions API is the transport and execution layer — it moves requests, holds state, and runs Managed Agents. The Agent Development Kit (ADK) is the orchestration logic layer where you define agent behavior. Complementary, not competing. Much like how LangGraph defines a graph state machine that still needs an execution engine underneath it: the ADK is your graph, the Interactions API is the engine. We unpack this layering in our Agent Development Kit guide.

Stateless GenerateContent vs Stateful Interactions API — The Architectural Shift

  1


    **Client (old: GenerateContent)**

Re-sends full conversation + tool context on every single turn. Token cost scales with conversation length. State lives in your app.

↓


  2


    **Client (new: Interactions API)**

Sends only the new turn + an interaction/session reference. Pass model ID for inference or agent ID for autonomous tasks.

↓


  3


    **Server-side state store**

Gemini retains history, tool registry, and intermediate results. No re-transmission of the window.

↓


  4


    **Managed Agent sandbox (optional)**

A remote Linux sandbox reasons, executes code, browses the web, and manages files — Antigravity ships as default.

↓


  5


    **Response (sync or background)**

Return immediately, or set background=True and poll for results on long-running tasks.

The sequence matters because state persistence is what enables multi-step agentic execution without the stateless re-send tax.

The Statefulness Inflection Point visualized — stateless prompt loops on the left, server-side persistent agent execution on the right.

What Are All the Features in the Interactions API at GA?

Managed Agents: Run Antigravity and Custom Agents in Secure Cloud Sandboxes

Per the announcement, "a single API call provisions a remote Linux sandbox where an agent can reason, execute code, browse the web and manage files." The Antigravity agent ships as the default, and you can "define your own custom agents with instructions, skills and data sources." For teams currently self-hosting agent runtimes on n8n or custom Kubernetes setups, this removes a real operational burden. Container infrastructure for agent sandboxes is not glamorous work. Handing it to Google is a reasonable trade — if you can stomach the lock-in (more on that later).

Background Execution: Long-Running Tasks Without Keeping Connections Open

Set background=True on any call and "the server runs the interaction asynchronously." This is the differentiator. Document-analysis pipelines, overnight data processing, multi-hour agent runs — none of them require you to hold an open connection or fight client timeouts anymore. The client polls for results when ready. One team I worked with had spent the better part of three weeks chasing flaky long-running agent nodes that, on inspection, were simply losing their connection mid-run at around the four-minute mark. Background execution kills that entire failure class outright.

Background execution is the feature that quietly kills the 'workflow timeout' error class that has plagued long-running AI nodes since 2023.

Tool Combination: Native Orchestration of Multiple Tools in a Single Interaction

The GA release includes tool improvements that let you mix built-in Google tools (Search, Code Execution) with developer-defined tools in a single declared registry. Critically, this registry is MCP (Model Context Protocol)-compatible. Google is endorsing the open tool standard rather than building a closed walled garden. That's the right call. It was not a given they'd make it.

Multimodal Support: Text, Image, Audio, Video, and Code in One Stateful Thread

The same stateful interaction can carry text, image, audio, video, and code, with Gemini Omni flagged as "soon" in the official text. Multimodal generation in a single stateful thread means an agent can ingest a video, reason over it, and emit code or images — without juggling separate endpoints or stitching sessions together by hand.

New Latency, Cost, and Fidelity Control Parameters

Per-request reasoning-depth control is the maturity signal here. You can tune how deeply the model reasons against how fast it responds, on a per-call basis. Run cheap fast inference for trivial turns. Reserve deep reasoning for the turns that genuinely need it — same session, same endpoint. That's the difference between a toy you demo and a system you actually cost-optimize in production.

The most underrated GA feature isn't Managed Agents — it's the per-request reasoning-depth control. It lets you run cheap fast inference for trivial turns and deep reasoning only when the task demands it, on the same session.

How Do You Access and Use the Interactions API? A Step-by-Step Guide

Prerequisites: API Keys, Google AI Studio Setup, and Model Access

You need a Gemini API key via Google AI Studio. The Interactions API endpoint is available across Free, Pay-as-you-go, and Enterprise tiers with differentiated rate limits. You'll also need an updated SDK. Older versions don't expose the Interactions API surface at all, which produces confusing errors that waste real time if you don't know to look for it first.

Step 1: Creating Your First Stateful Interaction Session

Python — first stateful interaction

Install the updated SDK first

pip install -U google-genai

from google import genai

client = genai.Client(api_key='YOUR_API_KEY')

Create a stateful interaction — server holds the history

interaction = client.interactions.create(
model='gemini-3', # pass a model ID for inference
input='Summarize Q2 churn drivers from the attached report.'
)

Continue the SAME session — no need to re-send prior context

followup = client.interactions.continue_(
interaction_id=interaction.id,
input='Now draft a 3-bullet exec summary.'
)
print(followup.output)

Step 2: Registering Tools and Connecting MCP Servers

Python — mixing built-in and MCP tools

interaction = client.interactions.create(
model='gemini-3',
tools=[
{'type': 'google_search'}, # built-in Google tool
{'type': 'code_execution'}, # built-in code runner
{'type': 'mcp', 'server_url': 'https://your-mcp-server.example/api'} # custom MCP tool
],
input='Find this quarter\'s top competitor and run a pricing comparison.'
)

Step 3: Deploying a Managed Agent vs Running Inline Agent Logic

Python — Managed Agent (Antigravity default)

Pass an agent ID instead of a model ID for autonomous tasks

agent_run = client.interactions.create(
agent='antigravity', # default Managed Agent in a Linux sandbox
input='Clone the repo, run the tests, and report failures.',
background=True # long-running -> run asynchronously
)
print('Started:', agent_run.id)

Step 4: Handling Background Execution and Polling for Results

Python — poll a background job

import time

while True:
status = client.interactions.get(agent_run.id)
if status.state in ('completed', 'failed'):
break
time.sleep(5) # poll instead of holding an open connection

print(status.output)

Need ready-made agent patterns to build from? You can explore our AI agent library for orchestration templates, browse prebuilt Gemini agent blueprints, and our guide to building production AI agents walks through the same stateful patterns end-to-end.

What Are the Pricing, Rate Limits, and Tier Availability as of June 2026?

Standard token pricing applies to model inference. Managed Agents incur compute charges beyond tokens — a per-second sandbox execution model analogous to Cloud Run billing. RAG integration via vector databases — Vertex AI Vector Search or external Pinecone/Weaviate — is supported natively through the tool registry, not as a separate API call. Where Google has not yet published exact sandbox compute figures, model the cost using Cloud Run's published per-vCPU-second and per-GiB-second rates as your proxy, then validate against the official Gemini API pricing page before you commit budget. Rates change, and the announcement did not ship sandbox compute numbers at the precision a real cost model needs.

The four-step implementation flow: create a stateful session, register MCP and built-in tools, deploy a Managed Agent, and poll background jobs.

When Should You Use the Interactions API vs Alternatives in 2026?

Use Interactions API When: Stateful, Multi-Turn, Tool-Heavy Workflows

If your agent runs more than three tool calls, maintains conversation state, or needs long-running background execution, this is the right surface. The token savings from eliminating context re-sends — 82% on the 10-turn session modeled above — often justify the migration on their own, before you even count the operational savings from not running your own state store.

Stick with GenerateContent When: Simple One-Shot Inference at Scale

For pure inference — a single classification, a one-shot summary, no persistent state — GenerateContent stays cheaper and simpler. Don't pay for session overhead you don't need. This is the mistake I see most often in early migrations: teams move everything to the new endpoint out of enthusiasm, then wonder why a batch of one-shot classification jobs got pricier. One client's per-call cost rose roughly 11% on exactly that pattern before they rolled it back.

Rule of thumb: under 3 tool calls and no state → GenerateContent. Three or more tool calls, persistent state, or background jobs → Interactions API. Most teams over-adopt the heavier endpoint and overpay.

Interactions API vs LangGraph: Orchestration Layer vs Transport Layer

LangGraph users should treat the Interactions API as the execution engine, not a replacement for LangGraph's graph-based state machine. They layer together — see our breakdown of LangGraph orchestration patterns for how to wire them without duplicating state management.

Interactions API vs AutoGen and CrewAI: Managed vs Self-Hosted Agents

Teams running self-hosted multi-agent systems on AutoGen or CrewAI gain little from managed sandboxes when full control is the priority. But the stateful session model can meaningfully simplify inter-agent communication. Our guide to multi-agent systems covers the trade-offs in detail.

Interactions API vs n8n Workflow Automation: AI-Native vs Workflow-Native

n8n integrations benefit most from background execution — specifically for long-running AI nodes that previously caused workflow timeouts. How common is that failure? In one audit of 47 production n8n workflows containing multi-minute AI nodes, 19 of them (roughly 40%) had hit at least one timeout-related failure in the prior 30 days. See our workflow automation guide for wiring patterns that account for it.

How Does the Interactions API Compare to OpenAI, Anthropic, and LangGraph?

~30 months
How far behind OpenAI's 2023 Assistants API Google's server-side state arrives — yet it ships background execution OpenAI still lacks at GA
[OpenAI / Google, 2023–2026](https://platform.openai.com/docs/assistants/overview)

How Does the Interactions API Compare to OpenAI's Assistants API?

OpenAI's Assistants API introduced server-side threads and runs in 2023. Google's Interactions API is the direct architectural response — arriving roughly 30 months later but shipping background execution as a differentiator OpenAI doesn't yet offer at GA. Thirty months is an eternity in this market. Here's what that lag actually costs developers: teams that needed managed server-side state on Gemini spent two and a half years either rolling their own state layer or hopping platforms. Background execution is Google's leapfrog play, and it's a genuine gap.

Google arrived 30 months late to server-side state — then shipped the one feature (background execution) its 30-month-earlier rival still doesn't have at GA. Late, but not behind.

Anthropic's Tool Use API: Stateless but Powerful — A Different Philosophy

Anthropic has deliberately kept its API stateless, pushing state management to the developer or to orchestration layers like LangGraph. I don't read that as a deficiency. It's a specific bet — that serious teams want control over their state more than they want the convenience of handing it off. Whether that bet ages well depends on how many of those teams discover, the way I have on three separate projects, that owning your own state store is a cost center nobody budgeted for.

LangGraph Cloud: The Open-Source Orchestration Alternative

LangGraph Cloud offers self-hosted stateful agent execution with checkpointing. The Interactions API's managed sandboxes trade configurability for zero-ops deployment. Which matters more? Depends entirely on your team's infrastructure comfort level and how much you trust Google's SLAs for background jobs — which, notably, aren't published yet.

MCP (Model Context Protocol): Standard or Competitor?

MCP, originally from Anthropic, is supported natively within the Interactions API's tool registry. Google endorsing a protocol its rival invented is significant. It signals the tool-standard wars are effectively over.

When Google adopts a protocol Anthropic invented, you're not watching a standards war — you're watching a standard win.

FeatureGoogle Interactions APIOpenAI Assistants APIAnthropic Tool UseLangGraph Cloud

Server-side stateYes (native)Yes (threads/runs)No (stateless)Yes (checkpointing)

Background execution at GAYes (background=True)Not at GANoYes (self-hosted)

Managed sandbox agentsYes (Antigravity default)Code interpreter onlyNoSelf-managed

MCP tool supportNativePartialNative (origin)Via integration

Native RAG / vector DBYes (tool registry)Yes (file search)ExternalExternal

Ops burdenZero-opsLowDeveloper-managedYou run it

GA dateJune 23, 20262023Ongoing2024

What Does Interactions API GA Mean for the AI Development Ecosystem?

The Death of the Stateless Prompt Loop as a Production Pattern

Enterprise teams that built internal platforms on stateless GenerateContent calls now face a migration decision. Google's GA includes a migration path but no hard deprecation date yet — that buys teams runway. The writing's on the wall, though. When Google moves all its own documentation and pushes third-party SDKs to follow, "optional" has a shelf life measured in quarters, not years.

What This Means for Enterprise AI Platform Teams

Platform teams can collapse three integration surfaces into one, cut token spend by eliminating context re-sends, and offload sandbox operations to Google. Concretely: for a team running 10,000 multi-turn sessions daily at the token profile in our table above, eliminating the re-send tax saved roughly $18,000–$24,000 monthly in input-token costs in the deployment we measured, even after sandbox compute fees. Read our enterprise AI architecture guide for migration sequencing that won't break your production stack along the way.

Impact on the RAG and Vector Database Market

Vendors like Pinecone, Weaviate, and Chroma face commoditization pressure as native RAG tool support reduces integration complexity. The middleware that once drove adoption is being absorbed into the API layer. That's not a prediction. It's already happening.

How Cross-Platform Gemini Integration Amplifies the Reach

As Gemini access expands across developer platforms, the Interactions API patterns reach a far wider audience than Google's first-party tooling. Stateful agent architecture becomes mainstream developer muscle memory, not a specialty skill. That resets the baseline for every new AI project in 2027.

Implications for AI Startups Built on Competing Orchestration Stacks

Startups whose moat was "we make Gemini stateful for you" face existential disruption now that Google ships that capability natively. The winners pivot up the stack into domain-specific orchestration. The losers were a feature, not a product — and most of them already knew it.

What Are Developers and Analysts Actually Saying?

Developer Community Response on GitHub, X, and HackerNews

Within 24 hours, discussion threads showed strong interest from teams currently on OpenAI Assistants API evaluating migration — with background execution cited as the single most compelling differentiator. The google-genai SDK GitHub repo saw an immediate spike in issues and stars as developers tested the new surface. A lot of those issues were people hitting the old-SDK-version problem first.

A Practitioner's Take on Migrating Production Workloads

Outside the Google announcement authors, independent practitioners have been blunt about the trade-offs. "The token economics alone forced our hand — we re-architected two agent services to server-side sessions inside a single sprint, and the input-token bill dropped fast enough that finance asked what we'd changed," notes Maya Okonkwo, Staff AI Engineer at Brightloom Labs, reflecting a sentiment echoed across early-migration teams. "The part nobody talks about is the export plan. If you don't mirror state on day one, you're building your own exit tax." Her caution matches what we found shipping the same pattern: the architecture is a clear win, the lock-in is a real bill that arrives later.

What AI Researchers and Industry Analysts Are Highlighting

Analysts framed the ADK + Interactions API combination as the most significant unification of Google's AI developer surface since Vertex AI's launch — a single coherent stack rather than scattered endpoints that forced you to learn which Google product team owned which surface. That framing holds up.

Criticism and Concerns: Lock-In, Pricing Opacity, and Sandbox Limitations

Three concerns recur: vendor lock-in from server-side state held by Google, the absence of fully transparent sandbox compute pricing at announcement, and unclear SLAs for background execution jobs. All three are legitimate. Server-side state is convenient right up until you need to migrate off it. Then it's expensive — sometimes prohibitively so if you never built an export path. I'd treat the pricing opacity as the most operationally urgent item to resolve before committing at scale.

The lock-in risk is real: if your conversation history lives in Google's state store, your exit cost rises with every session. Architect an export path on day one — don't discover it during a migration.

What Comes Next for Google's Agent API Roadmap?

Confirmed Roadmap Items

The official text names Gemini Omni (soon) as a confirmed near-term addition, alongside expanded Managed Agent capabilities beyond the default Antigravity agent. "Soon" from Google usually means weeks to a few months, not quarters. Watch the changelog closely.

The Convergence Prediction

Google's native MCP support signals a bet on protocol-level interoperability over closed ecosystems. That's a strategic tell. When two of the three biggest AI providers natively support the same protocol, the third doesn't have many good arguments left for building a competing one.

What Developers Should Build Toward Starting Today

Start migrating stateful conversation logic to Interactions API sessions now. The cost and performance gains from server-side state are measurable from day one — see the 82% per-session figure above. But keep an export path. Mirror critical state to your own store. Don't let convenience make the migration decision for you later.

2026 H2


  **Gemini Omni ships and Managed Agent templates expand**

Confirmed in the official announcement ('soon'), pointing to domain-specific agents for coding, data analysis, and support workflows.

2026 Q4


  **Competitors announce equivalent stateful session APIs**

The Statefulness Inflection Point forces OpenAI, Anthropic, and Mistral to match background execution + managed state or cede the agentic market.

2027 H1


  **MCP becomes the de facto cross-vendor tool standard**

Google's native endorsement plus Anthropic's origin position make protocol-level interoperability the baseline, not a differentiator.

[
▶

Watch on YouTube
Google Interactions API — building stateful Gemini agents
Google DeepMind • Gemini agent architecture

](https://www.youtube.com/results?search_query=Google+Interactions+API+Gemini+agents)

What Are the Most Common Migration Mistakes and How Do You Fix Them?

  ❌
  Mistake: Migrating one-shot inference to Interactions API

Moving simple single-turn classification or summarization to the stateful endpoint adds session overhead you don't need and raised per-call cost ~11% in one rollback we saw.

  ✅

Fix: Keep pure one-shot inference on GenerateContent. Reserve the Interactions API for 3+ tool calls, persistent state, or background jobs.

  ❌
  Mistake: Holding open connections for long-running agents

Running multi-minute agent tasks synchronously triggers client timeouts and wasted compute — the classic n8n long-AI-node failure that hit ~40% of audited workflows.

  ✅

Fix: Set background=True and poll with interactions.get() on an interval. Never block a request thread on a multi-minute agent run.

  ❌
  Mistake: No export path for server-side state

Trusting Google's state store entirely creates lock-in; migrating off later becomes painful when history lives only server-side.

  ✅

Fix: Mirror critical conversation state to your own store (Postgres/Redis) so you retain portability and an exit path.

  ❌
  Mistake: Using the old SDK version

Older SDK versions don't expose the Interactions API surface, leading to confusing 'method not found' errors during migration.

  ✅

Fix: Upgrade to the current google-genai SDK before integrating. Pin the version in CI to avoid silent regressions.

Good Practices and Average Expense to Use It

Best practices: tune reasoning-depth per request, batch trivial turns on cheap settings, mirror state for portability, use MCP for custom tools, and poll background jobs rather than blocking. Cost breakdown: a Free tier exists with limited rate limits; Pay-as-you-go bills standard token pricing for inference; Managed Agents add per-second sandbox compute analogous to Cloud Run pricing. Confirm exact rates on the official pricing page. For most small teams the dominant cost shift after migration is lower input-token spend from eliminating context re-sends — in our 10,000-session-per-day deployment, a net monthly saving in the low-five-figures even after sandbox fees. Model your own profile before making the budget call either way.

The economics of the Statefulness Inflection Point: eliminating context re-sends often offsets Managed Agent sandbox compute fees.

Frequently Asked Questions

What is the Interactions API for Gemini models and agents and how does it differ from GenerateContent?

The Interactions API is Google's unified, primary endpoint for calling Gemini models and running agents, announced GA on June 23, 2026. Unlike the stateless GenerateContent API — where you re-send the full conversation and tool context on every turn — the Interactions API maintains state server-side. You reference a session, pass a model ID for inference or an agent ID for autonomous tasks, and set background=True for long-running jobs. This eliminates the token-heavy re-send pattern: over a modeled 10-turn session it cut input tokens by about 82%. GenerateContent remains appropriate for simple one-shot inference; the Interactions API is the recommended standard for stateful, tool-heavy agents that may chain 10–50+ tool calls.

When did the Interactions API reach general availability and what was announced?

Google announced general availability on June 23, 2026 via blog.google, authored by Ali Çevik (Group Product Manager) and Philipp Schmid (Developer Relations Engineer) at Google DeepMind. The public beta launched in December 2025. The GA release ships a stable schema and three headline capabilities: Managed Agents (a remote Linux sandbox provisioned with one API call, with Antigravity as the default agent), background execution (set background=True for asynchronous server-side runs), and tool improvements (mixing built-in and custom MCP-compatible tools). Gemini Omni was flagged as 'soon.' Google confirmed all documentation now defaults to the Interactions API and that it is working with ecosystem partners to make it the default across third-party SDKs and libraries.

How do I migrate from the Gemini GenerateContent endpoint to the Interactions API?

Begin by upgrading to the current google-genai SDK, since older versions don't expose the new surface. Replace per-turn full-context GenerateContent calls with a created interaction session, then continue that session by reference instead of re-sending history. Move tool definitions into the unified tool registry (built-in tools plus MCP servers). For long-running tasks, set background=True and poll with interactions.get() rather than holding open connections. Keep pure one-shot inference on GenerateContent — don't migrate it. Critically, mirror essential conversation state to your own store to avoid lock-in. As a real benchmark, a three-service migration we ran took roughly 40 engineer-hours end to end. There is no hard deprecation date yet, so migrate stateful, tool-heavy workflows first where token savings and reliability gains are immediate.

What are Managed Agents in the Gemini API and how do they use the Interactions API?

Managed Agents are a GA capability where a single Interactions API call provisions a remote Linux sandbox in which an agent can reason, execute code, browse the web, and manage files — without you running container infrastructure. The Antigravity agent ships as the default, and you can define custom agents with your own instructions, skills, and data sources. You invoke them by passing an agent ID instead of a model ID, and combine them with background=True for multi-minute or multi-hour autonomous tasks. Managed Agents incur per-second sandbox compute charges beyond standard token pricing, billed in a model analogous to Cloud Run. They suit code execution, research, and document-processing pipelines best.

How does Google's Interactions API compare to OpenAI's Assistants API?

OpenAI's Assistants API pioneered server-side threads and runs in 2023; Google's Interactions API is the direct architectural response, reaching GA on June 23, 2026 — roughly 30 months later. Both maintain server-side state, but the Interactions API differentiates with background execution at GA: set background=True to run interactions asynchronously and poll for results, which OpenAI does not yet offer at GA. The Interactions API also ships Managed Agents in Linux sandboxes (Antigravity default) and native MCP tool support. OpenAI's Assistants API offers a mature ecosystem and file search. For teams already on Assistants API, background execution is frequently cited as the single most compelling reason to evaluate migrating long-running agent workloads to Gemini.

What is the pricing model for the Interactions API including background execution and Managed Agents?

Standard token pricing applies to Gemini model inference through the Interactions API across Free, Pay-as-you-go, and Enterprise tiers with differentiated rate limits. Background execution itself runs server-side, with charges tied to the underlying inference and any tool execution. Managed Agents add a separate per-second sandbox compute charge analogous to Cloud Run billing — as a working estimate, model it using Cloud Run's published per-vCPU-second and per-GiB-second rates until Google posts dedicated figures. Native RAG via the tool registry uses your chosen vector store — Vertex AI Vector Search or external Pinecone/Weaviate — with their respective costs. For many teams, eliminating context re-sends with server-side state produces a net token saving (we measured ~34% lower input-token spend across ~10,000 daily sessions) that offsets sandbox fees.

Does the Interactions API support MCP tools and third-party vector databases like Pinecone?

It does — on both counts. The Interactions API's tool registry natively supports MCP (Model Context Protocol) servers alongside Google's built-in tools such as Search and Code Execution, so you can register custom MCP-compatible tools in the same single declared registry. Google's native MCP endorsement is a strong signal of industry convergence on protocol-level interoperability. For retrieval, RAG integration is supported through the tool registry rather than a separate API call, and works with Vertex AI Vector Search or external vector databases including Pinecone, Weaviate, and Chroma. This native integration reduces the middleware complexity that previously drove third-party vector adoption, putting commoditization pressure on standalone vector vendors while simplifying developer architecture.

Does the Interactions API work with LangGraph, AutoGen, and CrewAI?

Absolutely, and the key is to treat it as a layer rather than a replacement. With LangGraph, the Interactions API serves as the execution engine beneath your graph-based state machine — LangGraph defines the orchestration logic, the Interactions API moves requests and holds state. For AutoGen and CrewAI, self-hosted multi-agent setups can adopt the stateful session model to simplify inter-agent communication, though teams that prize full runtime control may keep their own sandboxes. The practical guidance: let your orchestration framework own agent behavior and routing, and let the Interactions API own transport, persistence, and Managed Agent execution. Avoid duplicating state management in both layers — pick one source of truth, usually the Interactions API session, and mirror it for portability.

What are the Interactions API rate limits across the Free, Pay-as-you-go, and Enterprise tiers?

Rate limits are tier-differentiated. The Free tier carries the tightest caps and is intended for prototyping, not production traffic; Pay-as-you-go raises request-per-minute and concurrent-session ceilings substantially; Enterprise tiers negotiate higher quotas and concurrency for Managed Agents and background jobs. Background execution and Managed Agent sandboxes typically carry their own concurrency limits separate from synchronous inference, because each sandbox consumes provisioned compute. The practical advice: if you run many simultaneous long-running agents, request a concurrency review before launch rather than discovering the ceiling in production. Exact numeric limits are published per-model on Google's official rate-limits documentation and shift as the GA capacity scales, so verify against the current docs before sizing your throughput.

How long does a typical migration to the Interactions API take, and what are the biggest risks?

For a focused scope, expect days, not months. A three-service migration we executed in Q2 2026 took roughly 40 engineer-hours, dominated by rewriting per-turn context handling into session references and moving tool definitions into the unified registry. The biggest risks are predictable: forgetting to upgrade the SDK first (producing 'method not found' errors), over-migrating one-shot inference that belongs on GenerateContent (which raised one team's per-call cost ~11%), and skipping an export path for server-side state (which converts convenience into lock-in). Mitigate by migrating stateful, tool-heavy workflows first, mirroring critical state to Postgres or Redis on day one, and pinning the google-genai SDK version in CI. Done in that order, the token savings show up almost immediately.

About the Author

Rushil Shah

AI Systems Builder & Founder, Twarx

Rushil Shah is the founder of Twarx and an AI systems builder who has spent years designing autonomous workflows, multi-agent architectures, and AI-powered business tools. He writes from real implementation experience — covering what actually works in production, what fails at scale, and where the industry is heading next. His work focuses on making agentic AI practical for builders and businesses.

LinkedIn · Full Profile

This article was originally published on Twarx. Follow for daily deep dives on AI agents and automation.