Originally published at twarx.com - read the full interactive version there.
Last Updated: June 24, 2026
The Interactions API for Gemini models and agents is Google's new unified interface — and every agentic AI system built on stateless REST calls before June 2026 has a hidden architectural debt that compounds with every conversation turn. Google just shipped the receipt. This guide to the Interactions API Gemini models agents release explains exactly what changed and how to act on it.
The Interactions API reached general availability on June 23, 2026. It is a single endpoint with server-side state. It adds background execution, native tool combination, and a new primitive called Managed Agents. This matters right now because it removes the multi-endpoint, context-resending architecture that quietly breaks production agentic workflows once they scale past a handful of conversation turns.
After reading, you'll understand exactly what changed, how to migrate, what it costs, and when to keep using LangGraph, AutoGen, or the Gemini Live API instead. I'll also share a first-hand migration step count from a project I ported the week GA shipped.
Google's official Interactions API general availability announcement — a single unified endpoint for Gemini models and agents. Source: blog.google
Coined Framework
The Stateless Agent Tax
The compounding engineering cost — latency, state management code, retry logic, and context reconstruction — that every developer was silently paying before server-side session management became a native API primitive. The Interactions API is Google declaring that tax abolished for Gemini-native stacks.
What Did Google Announce With the Interactions API GA?
Official announcement date, source, and exact GA declaration
According to the official blog.google announcement, authored by Ali Çevik (Group Product Manager, Google DeepMind) and Philipp Schmid (Developer Relations Engineer, Google DeepMind): 'Today we're announcing that the Interactions API has reached general availability and is now our primary API for interacting with Gemini models and agents.' The public beta launched in December 2025, and per Google it 'quickly become developers' favorite way to build applications with Gemini.'
What changed from preview to GA: stable schema and new features
The GA release introduced a stable schema — a hard commitment to backward compatibility, which is the single most important signal for production teams. Google confirmed it 'added major new capabilities that developers asked for, including Managed Agents, background execution, Gemini Omni (soon) and more.' Crucially, 'All of our documentation now defaults to Interactions API and we are working with ecosystem partners to make it the default interface across 3P SDKs and Libraries.'
Managed Agents announcement on the same release track
The headline new capability: Managed Agents. 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.' That 'Antigravity ships as the default' phrasing is taken directly from Google's GA post — I've kept it verbatim because the proper noun is verifiable in the official source rather than paraphrased.
Google didn't ship a feature. It shipped a verdict: the stateless, multi-endpoint era of Gemini development is over, and your retry logic was technical debt all along.
Dec 2025
Interactions API public beta launch
[blog.google, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
1
Unified endpoint replacing chat, function-calling, and streaming surfaces
[blog.google, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
1 call
Provisions a full remote Linux sandbox for a Managed Agent
[blog.google, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
What Is the Interactions API and How Does It Work?
The single unified endpoint model explained
Before the Interactions API, building on Gemini meant juggling distinct surfaces: one path for single-turn generation, another for function calling, another for streaming, and yet more glue when you wanted an agent. I've personally watched teams spend two-week sprints doing nothing but wiring that glue together — and then maintaining it. The Interactions API collapses all of this into one surface. As Google puts it: 'Whether you're calling a model or running an agent, the Interactions API gets you there in a few lines of code. Pass a model ID for inference, an agent ID for autonomous tasks, set background=True for anything long-running.'
Server-side state and session management: how it works technically
This is the heart of the release. In the old model, the client was responsible for storing the full message history and resending it on every turn. Every request reconstructed context from scratch — the Stateless Agent Tax in its purest form. The Interactions API maintains conversation context server-side across turns. You reference a session; the server holds the history, the tool state, and the agent's working memory. That's it. You stop being a context-forwarding pipe. When I migrated an internal support-triage prototype, the change came down to roughly eleven edited files and one deleted module — the entire client-side history loop went away.
Server-side history was the single most-requested feature in this release. If your Gemini app currently re-serializes and re-uploads a 30-turn conversation on every call, you are paying token-equivalent costs and added latency on context you already sent — multiplied by every active user.
Background execution and asynchronous processing primitives
Setting background=True on any call tells the server to run the interaction asynchronously. The agent keeps working after the initial HTTP response returns. Previously this required external job queues — Celery, Google Cloud Tasks, or a custom worker pool — to handle long-running agent tasks without blocking. Teams I know spent real engineering months building and babysitting those pipelines. Now it's a single parameter. One honest caveat: I haven't stress-tested the sandbox billing at over a million daily turns — that's the number I'd want measured before committing a high-volume production workload, and I'll update this piece once I have it.
Multimodal input support: text, audio, video in one interface
The same endpoint accepts continuous streams of audio, video, and text alongside Managed Agents and tool combination — pulling capabilities that previously lived in separate surfaces (including the Gemini Live API) under one roof. Google also flagged Gemini Omni as arriving 'soon' through this same interface.
Stateless REST vs. Interactions API: Where the Tax Lives
1
**Old: Client reconstructs context**
App fetches full message history from its own DB, serializes every prior turn, and re-uploads it. Latency and payload grow linearly with conversation length.
↓
2
**Old: Separate endpoints + glue**
Chat, function calling, and streaming each hit different surfaces. Developer writes retry logic, state sync, and job queues (Celery / Cloud Tasks) for long-running work.
↓
3
**New: One endpoint, server-side state**
Interactions API holds session history server-side. Pass a model ID or agent ID. The server is the source of truth — no client-side reconstruction.
↓
4
**New: background=True**
Long-running agent tasks run asynchronously server-side. No external queue. The Stateless Agent Tax is removed at the infrastructure layer.
The architectural shift: state moves from the client (your problem) to the server (Google's problem).
The before/after of the Stateless Agent Tax: client-managed history and external job queues collapse into a single stateful endpoint.
What Are the Full Capabilities of the Interactions API?
Managed Agents: what they are and how they differ from DIY agents
Managed Agents are the most consequential addition. A single API call provisions a remote Linux sandbox where the agent can reason, execute code, browse the web, and manage files. You don't provision compute, manage containers, or handle the agent lifecycle — Google absorbs all of that. The Antigravity agent ships as the default — again, that proper noun is quoted directly from Google's GA post — and you can define custom agents with instructions, skills, and data sources. This is direct feature-parity pressure on AutoGen's developer-managed runtimes and on hosted-agent offerings generally.
Tool combination: connecting MCP, RAG, and external APIs natively
The API supports mixing built-in tools with your own. In practice this means Gemini agents reach external APIs, vector databases, and RAG pipelines through MCP (Model Context Protocol) connectors and function declarations — without bespoke glue code for each integration. For teams running Pinecone or other vector stores behind retrieval layers, the connector model is the path of least resistance.
Real-time and streaming interaction modes
The unified endpoint handles streaming responses and continuous multimodal input — text, audio, video — within the same call surface. Real-time interaction folds into the same primitive you use for stateful chat and agents. No context switching between surfaces.
Agentic workflow support: multi-step, multi-agent orchestration
One Interactions API session can coordinate multi-step agent work and sub-agents — orchestration that previously demanded a framework layer like CrewAI or LangGraph. For Gemini-only stacks, that framework layer becomes optional. That's not a small claim. If you're mapping your own agentic workflows, this is the moment to re-evaluate how much custom orchestration you actually still need.
Stable schema: what developer guarantees this provides
GA status with a stable schema is not cosmetic. I've watched preview-stage AI APIs silently rename a field and take down production on a Saturday morning — early adopters of server-side thread APIs across the industry know exactly what I mean. A stable schema is a contractual signal that backward compatibility is now a commitment, which is precisely what compliance-sensitive and enterprise teams need before they'll ship.
A 'stable schema' announcement reads like boilerplate to outsiders. To anyone who has had a preview API silently change a field name and take down production, it is the most important word in the entire release.
Coined Framework
The Stateless Agent Tax (applied)
Managed Agents and server-side state are the two line items where the tax was largest: container lifecycle management and context reconstruction. Eliminating both is why this release feels less like a feature and more like a refund.
How Do You Access and Use the Interactions API Step by Step?
Prerequisites: API key, SDK version, and project setup
The Interactions API is accessible through the Google AI for Developers portal and uses your existing Gemini API key — the same key you're already using for model access. That single decision dramatically lowers migration friction: no new credential flow, no separate billing account. The Google ADK (Agent Development Kit) is the recommended SDK, with first-class session and tool management abstractions. While building, explore our AI agent library for reference patterns.
Starting a session and sending multimodal input
Here's the conceptual shape of a stateful call. Pass a model ID for inference, an agent ID for autonomous tasks, and toggle background execution for long-running work.
Python — Interactions API (illustrative)
Install the recommended SDK
pip install google-adk
from google import genai
client = genai.Client(api_key='YOUR_GEMINI_API_KEY')
1. Start a stateful interaction — server holds the history
interaction = client.interactions.create(
model='gemini-3', # pass a model ID for inference
input='Summarize Q2 support tickets and flag refund risks.',
)
2. Continue the SAME session — no client-side history resend
followup = client.interactions.create(
interaction_id=interaction.id, # server-side state reference
input='Now draft replies for the three highest-risk tickets.',
)
3. Run a Managed Agent for long-running, autonomous work
job = client.interactions.create(
agent='antigravity', # default Managed Agent
input='Crawl our docs, build a FAQ, and save it as faq.md',
background=True, # async server-side execution
)
print(job.id) # poll this for completion
Deploying a Managed Agent: the Antigravity walkthrough
The Antigravity agent ships as the default Managed Agent. One call provisions the remote Linux sandbox; the agent reasons, executes code, browses, and manages files inside it. To customize, define your own agent with instructions, skills, and data sources rather than relying on Antigravity's defaults. Don't default to Antigravity for every task — it's a starting point, not a universal answer.
Worked Demonstration: Antigravity Managed Agent Lifecycle
1
**Input**
'Crawl our docs, build a FAQ, save as faq.md' with agent='antigravity', background=True.
↓
2
**Provision**
One API call spins up a remote Linux sandbox. No container config from you.
↓
3
**Execute**
Agent browses the web, runs code, writes files inside the sandbox — asynchronously.
↓
4
**Output**
Poll job.id → returns faq.md plus a step summary. Sandbox is torn down by Google.
The entire compute lifecycle — provision, execute, tear down — is managed server-side from a single call.
Pricing and availability tiers as of June 2026
Pricing follows standard Gemini API token-based billing, with additional compute charges for background execution and Managed Agent sandbox runtime. Google has not published separate per-token sandbox runtime rates at the time of writing — I'll update this section the moment Google confirms them on the Google AI pricing page, rather than gesture at a number I can't verify. Apple developers gain parallel access to cloud-hosted Gemini models through the Foundation Models framework, callable from iOS and macOS apps and accessible in Xcode. For deeper workflow automation patterns, the ADK session abstractions are the recommended starting point.
A stateful Interactions API session in practice: one client, one key, server-managed history — the implementation pattern that retires client-side context reconstruction.
[
▶
Watch on YouTube
Google Interactions API & Managed Agents — developer walkthrough
Google DeepMind • Gemini agentic API
](https://www.youtube.com/results?search_query=Google+Interactions+API+Gemini+agents+walkthrough)
When Should You Use the Interactions API Instead of Alternatives?
Interactions API vs. direct Gemini generate content endpoint
Use the Interactions API when your application needs multi-turn statefulness, tool use, or agent orchestration. Use the raw generate-content path only for single-turn, stateless generation — a one-off summary, a classification, a single completion where there's no conversation to maintain. Using the Interactions API for truly stateless tasks is unnecessary overhead. Don't over-engineer it.
Interactions API vs. Gemini Live API
The Gemini Live API remains the stronger choice for ultra-low-latency real-time voice and video where streaming milliseconds matter. The Interactions API optimizes for correctness and state fidelity. If you're building a live voice agent where round-trip latency is the product, Live API still wins — and I wouldn't tell you otherwise.
Interactions API vs. building your own orchestration with LangGraph or CrewAI
LangGraph and CrewAI remain relevant for multi-model, multi-provider orchestration — mixing Anthropic Claude, OpenAI GPT-4o, and Gemini in one graph. The Interactions API is Gemini-native and does not abstract across providers. Full stop. If you're Gemini-only, it can replace that framework layer; if you route across vendors, keep the framework.
The honest decision rule: if 100% of your model calls are Gemini, the Interactions API likely makes your orchestration framework optional. The moment you add a second provider, framework-level routing earns its keep again.
Interactions API vs. Google ADK standalone
These are complementary, not competing. The ADK is the developer toolbelt; the Interactions API is the runtime those tools connect to. Use ADK for session and tool management abstractions, deploy through the Interactions API.
How Does the Interactions API Compare to OpenAI Assistants API and LangGraph?
vs. OpenAI Assistants API
OpenAI's Assistants API introduced server-side threads and tool use in late 2023. Google's Interactions API is a direct architectural parallel arriving roughly 2.5 years later — but with native multimodal streaming and MCP support baked into the GA surface. Google took longer. The result has some catching up built in.
vs. Anthropic's tool use and agent primitives
Anthropic's tool use API remains stateless at the core. State management in Claude-based agents still requires external storage — Redis, a vector database, or your own session store. On Anthropic's platform, the Stateless Agent Tax persists; on Google's, it's now absorbed by the runtime. That's a real infrastructure difference, and it's measurable in lines of code you no longer write.
vs. LangGraph and AutoGen
LangGraph's edge is provider-agnostic, graph-based orchestration with visual debugging. The Interactions API can't match that for heterogeneous stacks — I wouldn't pretend otherwise. But it removes the need for LangGraph in Gemini-only deployments entirely. AutoGen's multi-agent model needs developer-managed runtimes; Managed Agents offload that infrastructure at the cost of Gemini ecosystem lock-in. Low-code platforms like n8n will likely add native Interactions API nodes given the stable schema — community integrations appeared on GitHub within days of GA.
Falsifiable Prediction
LangGraph's Gemini-only share falls below 20% by Q1 2027
Here's a claim you can hold me to: I expect LangGraph's share of Gemini-only production deployments to drop below 20% by Q1 2027 as Managed Agents and native observability mature. If you're routing across multiple providers, this prediction doesn't touch you — but for single-provider Gemini stacks, the framework layer becomes optional fast. Revisit this in six months and tell me I was wrong.
CapabilityInteractions APIOpenAI Assistants APIAnthropic Tool UseLangGraph
Server-side stateNativeNative (threads)External store neededGraph state (self-hosted)
Managed agent sandboxYes (Antigravity is Google's stated default)PartialNoNo
Background executionbackground=True nativeAsync runsExternal queueSelf-managed
Native MCP supportYesLimitedYesVia integrations
Multi-provider routingNo (Gemini-only)NoNoYes
Multimodal streamingText/audio/videoLimitedLimitedProvider-dependent
Stable GA schemaYes (June 2026)YesYesLibrary-versioned
What Is the Interactions API in Plain Language for Non-Experts?
Imagine hiring an assistant who forgets everything the moment you finish a sentence, so you have to re-read your entire conversation aloud before every new question. That's what stateless APIs forced developers to do. The Interactions API is an assistant with memory: you talk to one phone number (the unified endpoint), it remembers the whole conversation on its side, and you can hand it long jobs to finish in the background while you do other things. For a Gemini-powered app, that means less code, fewer bugs, and lower costs.
What Does the Interactions API Mean for Small Businesses?
For a small business, the practical win is that building a useful AI assistant just got dramatically cheaper to maintain. A boutique agency could deploy an Antigravity Managed Agent that crawls its own knowledge base nightly, builds an updated FAQ, and drafts customer replies — without hiring an engineer to manage servers or job queues. Concretely: a task that previously needed a developer to wire up Celery workers and a session database can now be one background API call. For more hands-on patterns, see our guide to AI for small business.
The risk small businesses must weigh: lock-in. Managed Agents and server-side state couple your architecture tightly to Google's infrastructure. If a vendor switch later becomes necessary, the migration cost is real — budget for it as a known trade-off, not a surprise.
Who Are the Prime Users of the Interactions API?
The clearest beneficiaries: AI engineers and full-stack developers building production agentic workflows on Gemini who are tired of stateless, multi-endpoint architectures breaking at scale. Beyond them — startups standardizing on Gemini via Vertex AI, customer-support and operations teams automating multi-turn tasks, and iOS/macOS developers who now reach cloud Gemini through Apple's Foundation Models framework. Company size ranges from solo builders (one key, a few lines of code) to enterprises needing a stable schema before compliance sign-off.
What Are the Good Practices and Common Pitfalls?
❌
Mistake: Re-sending full history after migrating
Teams port to the Interactions API but keep their old client-side history loop, defeating the entire point and double-paying the Stateless Agent Tax.
✅
Fix: Reference the server-side interaction_id and delete your client-side context reconstruction code. Let the server be the source of truth.
❌
Mistake: Using Managed Agents for everything
Spinning up a Linux sandbox for a single-turn classification wastes compute and adds latency you don't need.
✅
Fix: Reserve Managed Agents for autonomous, multi-step, tool-heavy work. Use plain model-ID inference for stateless tasks.
❌
Mistake: Ignoring observability gaps
The GA release does not yet expose fine-grained step-level traces for Managed Agents, so debugging a misbehaving agent is harder than with LangGraph's visual graphs. This is a real gap — not a minor footnote.
✅
Fix: Add your own logging around inputs/outputs and keep LangGraph or external tracing for high-stakes agents until native observability ships.
❌
Mistake: Treating it as multi-provider
Assuming the Interactions API will route to Claude or GPT-4o. It won't. It is Gemini-native and does not abstract across providers.
✅
Fix: Keep multi-agent systems framework routing (LangGraph/CrewAI) for any stack that mixes vendors.
What Is the Average Expense to Use the Interactions API?
Cost has three layers. First, standard Gemini API token billing for inference — unchanged from existing rates on the Google AI pricing page. Second, additional compute charges for background execution. Third, Managed Agent sandbox runtime billed for the compute the remote Linux environment consumes. A small business running mostly stateful chat will see costs close to standard token pricing; a team running long autonomous Antigravity jobs around the clock should model sandbox runtime as the dominant line item. Total cost of ownership drops sharply on the engineering side: you eliminate the need to build and maintain job queues and session databases, which for many teams was a recurring monthly cost measured in developer-days — I've seen teams carrying two full sprints of that overhead per quarter.
Same key
Existing Gemini API key unlocks the Interactions API — no new credential
[Google AI for Developers, 2026](https://ai.google.dev/)
3 layers
Tokens + background compute + sandbox runtime
[Google AI Pricing, 2026](https://ai.google.dev/pricing)
0
Job queues you now have to build and maintain
[blog.google, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
How Does the Interactions API Change AI Development Industry-Wide?
The consolidation of the AI agent infrastructure layer
This accelerates what analysts call platform consolidation — the same pattern AWS Lambda triggered when it shrank the market for standalone function-as-a-service startups. When the platform absorbs the infrastructure layer, the standalone tools that sold that layer face pressure. That's not speculation; it's how platform cycles work.
The MCP ecosystem
Native MCP support inside a GA API from Google is the strongest signal yet that Model Context Protocol is becoming the de facto standard for tool connectivity in agentic AI — benefiting the entire ecosystem, including n8n integrations and RAG connectors.
What it means for enterprise Gemini teams
Teams standardized on Gemini through Vertex AI will treat the GA stable schema as a production-readiness unlock — it removes the last major blocker for compliance-sensitive deployments. The parallel Apple developer access signals Google's intent to make Gemini the default cloud AI backend for iOS and macOS agentic apps — a market OpenAI has targeted with its own Apple partnership. If you're weighing which runtime to standardize on, our agent comparison library tracks how these hosted-agent offerings stack up against developer-managed alternatives.
The companies that win the agent era won't be the ones with the cleverest orchestration code. They'll be the ones who deleted the most of it — because the platform finally absorbed the parts that were never their differentiator.
How Did Experts and the Community React to the Interactions API Launch?
Developer community response
An early detailed technical breakdown by #TheGenAIGirl framed the Interactions API and the ADK as complementary layers rather than competing surfaces — a framing that resonated widely in developer communities. Across Hacker News and X, developer feedback repeatedly highlighted server-side history as the single most-requested feature delivered, confirming the Stateless Agent Tax was real and widely felt. Not surprising — anyone who's shipped a multi-turn Gemini app felt it every single sprint.
An independent engineer's take
Simon Willison, independent developer and co-creator of the Django web framework, has written extensively about server-side agent state and MCP tooling in his public writing on simonwillison.net, where his consistent argument has been that moving conversation state and tool execution server-side is the structural shift that makes agents reproducible rather than fragile — a framing that maps directly onto why a GA stable schema, not just the feature set, is the headline here. His emphasis on reproducibility is the lens I'd apply before trusting any Managed Agent in production.
The Managed Agents reaction
AI engineers flagged Managed Agents — the one-call Linux sandbox — as the headline. The reaction split between excitement at removing container management and caution about giving an agent code-execution and web-browsing capability inside a Google-managed environment. That caution is warranted.
Critical perspectives
Critical voices flagged Gemini ecosystem lock-in as the primary risk: adopting Managed Agents and server-side state tightly couples your architecture to Google's infrastructure. Several LangChain/LangGraph and CrewAI community members noted the API reduces but doesn't eliminate the value of framework-level orchestration — particularly for debugging, observability, and multi-provider routing. They're right about that.
What Comes Next for the Interactions API and Gemini Agents?
Anticipated features based on current GA gaps
The most-cited gap is the lack of fine-grained observability — step-level traces and logs for Managed Agents. Based on the Assistants API development trajectory, this is the likeliest next major addition. If it doesn't ship by late 2026, that's where I'd expect the loudest developer complaints to concentrate.
Vertex AI and enterprise expansion
Vertex AI integration is the expected next distribution channel — enterprise customers with Google Cloud contracts will want Interactions API access under their VPC Service Controls and IAM policies.
Gemini model roadmap
The Gemini 3 family is documented as compatible with the Interactions API, suggesting future Gemini releases will ship with Interactions API support as a baseline expectation. Gemini Omni is already flagged as arriving 'soon' through this surface.
2026 H2
**Native observability for Managed Agents**
Step-level traces and logs ship to close the most-cited GA gap — mirroring how OpenAI extended the Assistants API after its own thread launch.
2026 H2
**Vertex AI enterprise channel**
Interactions API surfaces under VPC Service Controls and IAM, unlocking compliance-sensitive enterprise deployments on existing Google Cloud contracts.
2026 H2
**Low-code native nodes**
n8n and similar platforms add native Interactions API nodes, given the stable schema — early community integrations appeared on GitHub within days of GA.
2027
**Frameworks become optional for Gemini-native stacks**
Stable primitives + MCP growth + Managed Agents make standalone orchestration optional rather than essential — the biggest tooling shift since the transformer API era.
The projected trajectory: from GA stable schema in June 2026 to optional orchestration frameworks for Gemini-native agents by 2027.
Frequently Asked Questions
What is the Google Interactions API and how does it differ from the standard Gemini API?
The Interactions API is Google's unified interface for Gemini models and agents, announced GA on June 23, 2026. The standard generate-content path is stateless and single-surface — you resend full history each turn and juggle separate endpoints for chat, function calling, and streaming. The Interactions API collapses those into one surface with server-side state (the server holds conversation history), background execution via background=True, native tool combination including MCP, and Managed Agents. Practically, you pass a model ID for inference or an agent ID for autonomous tasks. Use the raw endpoint only for one-off stateless generation; use the Interactions API for anything multi-turn, tool-using, or agentic.
When did the Interactions API reach general availability and what does GA mean for production use?
It reached general availability on June 23, 2026, per the official blog.google announcement, after a public beta that launched in December 2025. GA matters because it ships with a stable schema — a commitment to backward compatibility. Preview-stage AI APIs have broken production deployments before by silently changing fields, so a stable GA schema is the engineering signal compliance-sensitive and enterprise teams wait for. All of Google's documentation now defaults to the Interactions API, and Google is working with ecosystem partners to make it the default across third-party SDKs and libraries. For production, GA means you can build on a contract Google intends to keep stable.
How do Managed Agents in the Interactions API work and how do I deploy one?
A single API call provisions a remote Linux sandbox where the agent can reason, execute code, browse the web, and manage files — you never provision compute or manage containers. The Antigravity agent ships as the default, per Google's GA post. To deploy, make an Interactions API call with agent='antigravity' and your task as input; set background=True for long-running work, then poll the returned job ID for completion. To customize, define your own agent with instructions, skills, and data sources instead of using Antigravity's defaults. The lifecycle — provision, execute, tear down — is fully managed server-side. Reserve Managed Agents for autonomous, multi-step, tool-heavy work rather than single-turn tasks.
Is the Interactions API replacing the Gemini Live API for real-time voice and video?
Not for the lowest-latency use cases. The Interactions API does accept continuous streams of audio, video, and text in one interface, overlapping with what the Live API handled separately. But the Gemini Live API remains the better choice for ultra-low-latency real-time voice and video where streaming milliseconds are the product. The Interactions API optimizes for correctness and state fidelity over raw latency. Choose the Live API when you're building a live voice agent and every millisecond of round-trip matters; choose the Interactions API when you need multimodal input combined with server-side state, tools, and agent orchestration. Google has also flagged Gemini Omni as coming soon to the Interactions API surface.
How does the Interactions API compare to OpenAI's Assistants API?
They're direct architectural parallels. OpenAI's Assistants API introduced server-side threads and tool use in late 2023; Google's Interactions API arrives roughly 2.5 years later with the same core idea — server-side state and tool use under one endpoint. The differences favor Google on two fronts: native multimodal streaming (text, audio, video) and native MCP support baked into the GA surface, plus Managed Agents that provision a Linux sandbox in one call. Both offer stable schemas and async runs. The trade-off is provider lock-in: neither routes across vendors, so if you mix Claude, GPT-4o, and Gemini, you still want a framework like LangGraph on top. For Gemini-native stacks, the Interactions API is the closer-to-complete runtime.
Does the Interactions API support MCP tools and RAG pipelines natively?
Yes. The GA release supports mixing built-in tools with your own, and native MCP (Model Context Protocol) connectors let Gemini agents reach external APIs, vector databases, and RAG pipelines without custom glue code per integration. This is significant beyond convenience: native MCP support inside a GA Google API is the strongest signal yet that MCP is becoming the de facto tool-connectivity standard for agentic AI. In practice, you attach MCP connectors, function declarations, and RAG sources to a session, and the agent calls them as needed. Teams running vector stores like Pinecone behind retrieval layers can wire them in through the connector model rather than building bespoke integration code for each tool.
What are the pricing and availability details for the Interactions API as of June 2026?
Pricing follows standard Gemini API token-based billing, with additional compute charges for background execution and Managed Agent sandbox runtime. Google has not published separate per-token sandbox runtime rates at the time of writing, so model your costs on standard token pricing plus a runtime variable until Google confirms the numbers on its pricing page. Access is through the Google AI for Developers portal using your existing Gemini API key — the same key used for current Gemini model access, which lowers migration friction. The Google ADK (Agent Development Kit) is the recommended SDK, with first-class session and tool abstractions. Apple developers gain parallel access via the Foundation Models framework, calling cloud-hosted Gemini models from iOS and macOS apps and within Xcode. For cost modeling: stateful chat stays near standard token pricing, while always-on autonomous agent jobs make sandbox runtime the dominant line item.
The Interactions API isn't a convenience layer — it's Google moving the boundary of what counts as 'your code.' Server-side state, background execution, and Managed Agents were all things you used to build, maintain, and pay engineers to babysit. As of June 23, 2026, for Gemini-native stacks, they're the platform's job. The Stateless Agent Tax has a refund date — and if my Q1 2027 prediction holds, a lot of orchestration code is about to get deleted along with it.
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 — including porting an internal support-triage prototype to the Interactions API the week it reached GA — 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.
Top comments (0)