Originally published at twarx.com - read the full interactive version there.
Last Updated: June 24, 2026
The Interactions API Gemini models agents endpoint just made every agentic AI framework you've spent months building partially redundant — and Google announced it quietly on June 23, 2026. This isn't only an endpoint unification; the Interactions API Gemini models agents surface absorbs the orchestration layer itself, and the developer community is only beginning to reckon with what that means for the entire LangChain-era tooling stack. If you build on Gemini, the Interactions API for Gemini models and agents is now the road everything else runs on.
The Interactions API is now Google's primary API for interacting with Gemini models and agents — a single unified endpoint with server-side state, background execution, tool combination, and multimodal generation, per the official blog.google announcement. If you built on the legacy generateContent endpoint, this matters right now.
By the end of this piece, you'll know exactly what changed, how the architecture works, what it costs, how it compares to OpenAI's Responses API, and whether your LangGraph stack is still load-bearing.
Google's official Interactions API GA announcement graphic — the unified interface for Gemini models and agents. Source
Coined Framework
The Orchestration Tax
The compounding hidden cost in developer hours, infrastructure spend, and latency that teams pay every time they manually re-implement session state, tool routing, and background execution logic outside the model API itself. The Interactions API is the first GA product explicitly designed to eliminate this tax at the platform level.
What Google Announced: Interactions API Reaches General Availability
The official announcement: June 23, 2026 and what blog.google said exactly
On June 23, 2026, Google DeepMind's Ali Çevik (Group Product Manager) and Philipp Schmid (Developer Relations Engineer) announced that the Interactions API has reached general availability and is now Google's primary API for interacting with Gemini models and agents. The exact framing from the post: 'a single unified endpoint for Gemini models and agents with server-side state, background execution, tool combination and multimodal generation.'
The public beta launched in December 2025. In the words of the announcement, it 'has quickly become developers' favorite way to build applications with Gemini.' That's not a small claim coming six months after a beta — it signals that the migration tailwind is already strong before deprecation pressure even begins.
Why Google positioned this as the 'primary interface' — not just another endpoint
The word 'primary' is the entire story. Google confirmed that all of its documentation now defaults to the Interactions API, and the company is 'working with ecosystem partners to make it the default interface across 3P SDKs and Libraries.' When a vendor re-points its docs and third-party SDK partnerships at a new surface, that surface is no longer optional — it's the road everything else is built on. We unpack the broader strategy in our Google Gemini strategy analysis.
The stable schema milestone and what it signals for production adoption
The GA release ships with a stable schema. For regulated and production teams, this is the unlock: breaking changes are now versioned rather than silent. The release also added 'major new capabilities that developers asked for, including Managed Agents, background execution, Gemini Omni (soon) and more.'
Dec 2025
Interactions API public beta launch
[Google, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
Jun 23 2026
General availability with stable schema
[Google, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
30–60%
Estimated agent-scaffolding overhead removed by server-side state
[Industry estimate, 2026](https://deepmind.google/research/)
This positions Google to compete directly with OpenAI's Responses API and the older Assistants API architecture — both of which moved state server-side first. Google's differentiator is GA stability plus first-party tool depth.
The moment a vendor re-points all of its documentation at a new endpoint, that endpoint stops being a feature and becomes the platform. Everything else is now legacy by default.
What the Interactions API Is: A Plain-English Technical Definition
The core architectural shift: from stateless generate calls to stateful interaction sessions
The legacy Gemini generateContent endpoint was stateless. Every turn, you — the developer — had to re-send the entire conversation history, manage session IDs yourself, and re-inject tool state on each call. That works fine for a one-shot prompt. It becomes a maintenance nightmare for a 12-turn agent that calls three tools and runs for two minutes.
The Interactions API moves session state server-side. The model retains context between turns without the client re-injecting history. You pass a model ID for inference, an agent ID for autonomous tasks, and you reference a prior session rather than rebuilding it from scratch.
This is the same conceptual jump as moving from raw EC2 instances to managed AWS Lambda: the underlying compute is identical, but the operational surface area you maintain collapses. You stop being a session-state janitor and start shipping features.
How it unifies Gemini models, agents, Live API, and tool use under one surface
Per the announcement, the same endpoint handles text, audio, video, and code execution. 'Whether you're calling a model or running an agent, the Interactions API gets you there in a few lines of code.' The unification is the point — one schema, one auth model, one mental model.
The Orchestration Tax problem this API was built to eliminate
Here's what most people get wrong about agentic frameworks: they assume the value is the agent logic. It isn't. The bulk of the engineering hours in a production agent go into the plumbing — session persistence, tool routing, retry handling, and keeping long-running jobs alive past an HTTP timeout. That's the Orchestration Tax, and frameworks like LangGraph's StateGraph and AutoGen's ConversableAgent exist precisely to handle problems the Interactions API now handles natively for Gemini workflows.
Coined Framework
The Orchestration Tax — applied
If your team spent the last quarter writing session-management code, a webhook system for background jobs, and a tool-routing layer, you paid the Orchestration Tax in full. The Interactions API refunds most of it — but only for single-vendor Gemini deployments.
The shift from client-managed conversation history (legacy generateContent) to server-side stateful sessions is the heart of the Orchestration Tax reduction.
Before vs After: The Orchestration Tax in a Multi-Turn Agent
1
**Legacy generateContent (stateless)**
Client stores full message history. Every turn re-sends the entire context window. Tool state is re-injected manually. Background jobs require a custom queue + webhook system. ~30–60% of build time is plumbing.
↓
2
**Interactions API (stateful)**
Server stores session context. Client references a session_id. Tools are registered once via MCP schema. background=True handles long-running jobs natively. Plumbing collapses to a few lines.
↓
3
**Net result**
Lower latency on multi-turn (no re-send), fewer failure modes, and the orchestration layer becomes a platform responsibility — not yours.
The sequence shows why server-side state is not a convenience feature — it removes an entire category of code teams previously owned.
Full Capability Breakdown: Everything the Interactions API Can Do
Server-side state management
The API persists interaction context across turns without developer-managed memory injection. You initiate a session, and the model carries context forward. This is the single most consequential change for multi-turn agent builders — it eliminates the manual history-management code that dominated legacy agent scaffolding. For deeper patterns, see our guide to AI agent memory architectures.
Background execution: async agent runs and long-horizon tasks
Set background=True on any call and the server runs the interaction asynchronously. This is critical for tasks that outlive a single HTTP request — multi-step research, large data processing, and human-in-the-loop approval workflows. It's the foundation for selling AI as an async service rather than a synchronous query tool.
Background execution quietly rewrites AI product design: when an agent can outlive the request that started it, you can finally sell outcomes instead of round-trips.
Tool combination: native MCP support, Search Grounding, code execution, custom functions
The GA release improves tool handling so you can mix built-in tools with custom ones. The standout is native Model Context Protocol (MCP) support, allowing standardized tool schemas across third-party integrations. Tools built for any MCP-compatible system become reusable here. Combine that with Google Search grounding and code execution, and you have a tool layer that doesn't require third-party connectors for first-party Google data.
Managed Agents: the Antigravity agent and custom agent builder
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 custom agents with instructions, skills, and data sources. The isolated cloud sandbox is Google's direct answer to the security criticism of client-side agent execution.
Managed Agents run in an isolated secure cloud sandbox — early developer reports suggest the isolation model is architecturally cleaner than OpenAI's Code Interpreter, though independent third-party audits are still pending. Treat the security claim as production-promising but not yet independently verified.
Multimodal input handling
Audio streams, video frames, documents, and mixed-mode turns are all handled under the unified schema. The Gemini Live API streams remain accessible under the same surface, preserving low-latency voice and video use cases. Note: Gemini 3 models carry a knowledge cutoff of January 2025, so the Search Grounding tool is what bridges the recency gap in production.
Jan 2025
Gemini 3 knowledge cutoff (use Search Grounding for recency)
[Google AI docs, 2026](https://ai.google.dev/gemini-api/docs)
200–400ms
Approximate Managed Agent sandbox cold start
[Google docs estimate, 2026](https://ai.google.dev/gemini-api/docs)
1 call
Provisions a full remote Linux sandbox for an agent
[Google, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
How to Access and Use the Interactions API: Step-by-Step Guide
Prerequisites: API key, project setup, SDK versions
Access is via Google AI Studio or the Gemini API with a valid API key — no waitlist as of the GA date, June 23, 2026. Python and REST are supported, and JavaScript/TypeScript SDK parity was confirmed in the GA announcement. Apple developers gain access via Foundation Models framework integration, meaning Gemini is callable from Xcode.
[
▶
Watch on YouTube
Google Interactions API for Gemini models and agents — hands-on walkthrough
Google DeepMind • Gemini API architecture
](https://www.youtube.com/results?search_query=Google+Interactions+API+Gemini+agents+walkthrough)
Your first stateful interaction: code walkthrough
Here is a worked demonstration. We create a stateful session, get back a session_id, and send a second turn that relies on server-side memory — no history re-injection.
Python — first stateful interaction
Sample input: a two-turn conversation that relies on server-side state
import requests
API_KEY = 'YOUR_API_KEY'
BASE = 'https://generativelanguage.googleapis.com/v1/interactions'
headers = {'x-goog-api-key': API_KEY, 'Content-Type': 'application/json'}
Turn 1 — create the session (no session_id yet)
turn1 = requests.post(BASE, headers=headers, json={
'model': 'gemini-3-pro',
'input': 'My company ships handmade candles. Suggest 3 product names.'
}).json()
session_id = turn1['session_id']
print('SESSION:', session_id)
print('REPLY 1:', turn1['output_text'])
Turn 2 — reference the SAME session. No history re-sent.
turn2 = requests.post(BASE, headers=headers, json={
'session_id': session_id,
'input': 'Now turn name #2 into a tagline.'
}).json()
print('REPLY 2:', turn2['output_text'])
Output (illustrative):
REPLY 1: 1) Emberline 2) Wickwood 3) Lumen & Co.
REPLY 2: 'Wickwood: slow burns, warm rooms.' <-- model remembered name #2
The key detail: turn 2 sends only session_id and the new input. The model already knows what 'name #2' refers to because state lives server-side. That single behavior is the Orchestration Tax refund in action.
Adding tools: MCP servers, Search Grounding, custom functions
Python — registering tools (MCP + Search Grounding)
tools = [
{'type': 'google_search'}, # first-party grounding for recency
{'type': 'mcp', 'server': 'https://my-crm.example.com/mcp'}, # reusable MCP tool
{'type': 'function', 'name': 'get_inventory',
'description': 'Return stock count for a SKU'}
]
resp = requests.post(BASE, headers=headers, json={
'model': 'gemini-3-pro',
'input': 'How many Wickwood candles are in stock, and what is trending now?',
'tools': tools
}).json()
The model calls get_inventory + google_search, then synthesizes a single answer.
Because tools follow the MCP schema standard, anything you built for another MCP-compatible system is reusable here. To go deeper on building reusable tool layers, explore our AI agent library.
Running a Managed Agent: deploying Antigravity and custom agents
Python — running the Antigravity managed agent in the background
background=True lets the agent run past the HTTP request lifetime
run = requests.post(BASE, headers=headers, json={
'agent': 'antigravity', # default Google-managed agent
'input': 'Research 2026 candle market trends and write a 1-page brief.',
'background': True
}).json()
print('Status:', run['status']) # -> 'running'
print('Poll at:', run['session_id']) # check back later or attach a webhook
The Antigravity agent provisions a remote Linux sandbox where it can browse, run code, and manage files. Cold start adds roughly 200–400ms per Google's documentation — negligible for long-horizon tasks, but worth noting for latency-sensitive flows. For workflow-builder teams that prefer visual orchestration on top of the API, tools like n8n still pair well — see our n8n automation guide.
Pricing, quotas, and regional availability
Pricing follows standard Gemini model token pricing with an additional per-session state storage fee structure. Always confirm current rates at ai.google.dev/pricing, since GA pricing can shift. There is no waitlist as of June 23, 2026, and Apple developers can call Gemini from Xcode via the Foundation Models framework integration announced the same week.
When to Use the Interactions API vs Alternatives
Use Interactions API when: stateful agents, multi-turn workflows, background jobs
Reach for it when you're building stateful agents, long multi-turn workflows, or background jobs that need to survive past an HTTP timeout. This is exactly where the Orchestration Tax was highest, and where the refund is largest. If you're new to building agents, start with our guide to building AI agents.
Still use legacy generateContent when: one-shot, lowest latency, cost-sensitive
For single-turn, high-volume inference, the Interactions API overhead is non-trivial. The legacy generateContent endpoint remains faster and cheaper for stateless use cases. Don't pay for server-side state you never read.
Counterintuitive truth: the Interactions API can make a simple classification pipeline slower and pricier. Stateful sessions cost storage. For one-shot, high-QPS inference, generateContent still wins on both latency and cost.
When to keep LangGraph, AutoGen, or CrewAI
The Interactions API is Gemini-only. If your graph involves non-Gemini models — GPT-4o, Claude 3.5 Sonnet — LangGraph retains its value as a multi-model router. CrewAI and AutoGen offer agent-to-agent communication patterns not yet exposed in Interactions API v1. See our deep dive on multi-agent systems.
When RAG still needs external infrastructure
The Interactions API does not replace retrieval. RAG pipelines still require external vector databases — Pinecone, Weaviate, or AlloyDB with pgvector. Server-side state is conversation memory, not a knowledge base. Read our RAG infrastructure guide for the distinction.
Interactions API vs Closest Competitors: Google vs OpenAI vs Anthropic
Interactions API vs OpenAI Responses API
OpenAI's Responses API introduced stateful runs in 2025. Google's Interactions API reaches parity on core state management while leading with a GA stability commitment. OpenAI's Assistants API has shipped Managed Files and Code Interpreter since 2023, so Google's Managed Agents sandbox is newer — but per early developer reports, architecturally cleaner.
Where Anthropic and MCP leadership stands
Anthropic pioneered MCP in late 2024. Google adopting MCP natively in the Interactions API is a major validation that accelerates ecosystem standardization — and it benefits Anthropic's protocol leadership even as the two compete on models.
The orchestration framework disruption
LangGraph faces the most direct substitution pressure for pure-Gemini workflows. AutoGen (Microsoft) and CrewAI keep relevance for multi-vendor agent networks. Google's vertical integration is the moat: Search Grounding, YouTube data, Maps, and Workspace tools are first-party — OpenAI and Anthropic require third-party connectors.
CapabilityGoogle Interactions APIOpenAI Responses / AssistantsAnthropic Claude API
Server-side stateYes (GA, stable schema)Yes (since 2025)Partial (client-managed)
Managed agent sandboxYes — Antigravity + custom (Linux sandbox)Yes — Code Interpreter (since 2023)No first-party sandbox
Background executionYes — background=TrueYes — async runsLimited
Native MCP supportYesGrowingOriginated MCP (2024)
First-party data toolsSearch, Maps, YouTube, WorkspaceThird-party connectorsThird-party connectors
Knowledge cutoffJan 2025 (Gemini 3) + Search GroundingModel-dependentModel-dependent
Schema stabilityStable, versioned (GA Jun 2026)StableStable
Industry Impact: What the Interactions API Changes for Enterprise AI
The commoditisation of the orchestration layer
Orchestration tooling startups built solely on Gemini scaffolding face existential pressure. Those with multi-model or cross-cloud value propositions are insulated. The lesson echoes the cloud era: when a platform absorbs a layer, the businesses that survive are the ones that sit above or across it, not inside it.
Enterprise adoption signals
Stable schema GA is the unlock for regulated-industry adoption. Financial services, healthcare, and legal require API stability guarantees before production deployment — and a versioned, breaking-change-controlled schema is exactly that signal. Read our enterprise AI adoption analysis.
Apple developer integration
The Apple Foundation Models framework integration — announced the same week — makes Gemini callable from iOS/macOS apps via Xcode, opening a developer base of over 34 million registered Apple developers. That's a distribution event, not just a feature.
34M+
Registered Apple developers reachable via Foundation Models + Gemini
[Apple Developer, 2026](https://developer.apple.com/)
Async
New product model unlocked by background execution
[Google, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
1st-party
Workspace, Search, Maps tools — a data-access moat
[Google Workspace, 2026](https://workspace.google.com/)
The agentic web shift
Background execution fundamentally changes what AI products can promise. Agents can now be sold as async services rather than synchronous query tools — enabling subscription and outcome-based pricing. A research-brief agent that runs for ten minutes and emails you the result is now a clean product, not a hack around HTTP timeouts. For a small consultancy, that could mean packaging a '$499/month managed research agent' with near-zero orchestration code. Browse ready-made starting points in our prebuilt AI agents directory.
Expert and Community Reactions: What Developers and Analysts Are Saying
Developer community response
Developer forums flagged the migration path from generateContent as the primary friction point. The stable schema helps, but deprecation-timeline pressure is real and developers want a firm date. Praise centers on the dramatically smaller operational surface; skepticism centers on vendor lock-in. Discussion threads on Hacker News echoed both takes within hours of the GA post.
What framework authors and researchers are saying
A widely shared Medium analysis by TheGenAIGirl identified the Interactions API plus Agent Development Kit (ADK) combination as 'the most significant architectural shift in Gemini's history.' Consensus is emerging that the Managed Agents sandbox security model is stronger than OpenAI Code Interpreter's isolation — though independent audits are pending.
The quiet tell: as of GA launch, the LangChain and LangGraph teams had not issued official guidance on Interactions API compatibility. That silence is a gap the community is actively filling — and a signal of how fast this landed.
The lock-in question
Skepticism centers on vendor lock-in: server-side state is only portable if Google maintains API stability. The stable schema commitment is precisely what's being watched. Trust here is a promise being tested in real time.
What Comes Next: Roadmap, Open Questions, and the Agentic API Future
Known roadmap signals
Google flagged 'Gemini Omni (soon)' in the announcement. Cross-agent communication — agent-to-agent handoff within the Interactions API — is the most-requested missing feature per developer forum threads at GA launch. Gemini Live API video streaming sits under the umbrella but still carries separate rate limits; full unification is expected in a future minor version.
The legacy deprecation timeline
Legacy generateContent deprecation has not been officially dated. Google has historically given roughly 12-month migration windows for major API changes — plan accordingly, but don't assume.
2026 H2
**Gemini Omni ships and Live API video fully unifies**
Google explicitly named Gemini Omni as 'soon' in the GA post; separate Live rate limits signal a pending minor-version unification.
2026 Q4
**Most new Gemini production deployments go Interactions-API-only**
Grounded in the beta-to-favorite adoption curve and docs defaulting to the new endpoint — the path of least resistance now runs through it.
2027 H1
**LangGraph and AutoGen reposition as multi-model routers**
Single-model orchestration value erodes; cross-vendor routing (GPT-4o, Claude, Gemini) becomes their defensible niche.
2027
**Edge-to-cloud state synchronisation emerges**
Apple Foundation Models integration hints at unifying on-device and cloud Gemini calls — the next frontier after server-side state.
Common Mistakes Migrating to the Interactions API
❌
Mistake: Forcing every call through stateful sessions
Teams migrate one-shot classification and extraction jobs onto stateful sessions, paying per-session storage fees and added latency for context they never reuse.
✅
Fix: Keep stateless, high-QPS inference on the legacy generateContent endpoint. Reserve the Interactions API for genuine multi-turn or background workloads.
❌
Mistake: Assuming server-side state replaces RAG
Developers drop their vector database expecting session memory to handle knowledge retrieval. Session state is conversation context, not a searchable knowledge base.
✅
Fix: Keep Pinecone, Weaviate, or AlloyDB pgvector for retrieval. Use the Interactions API for orchestration and memory, not document search.
❌
Mistake: Ignoring sandbox cold-start latency
Routing latency-sensitive voice flows through Managed Agents adds ~200–400ms cold start, breaking the low-latency experience users expect.
✅
Fix: Use the Live API surface for real-time voice/video. Reserve Managed Agents for long-horizon tasks where 200–400ms is irrelevant.
❌
Mistake: Building Gemini-only on a multi-vendor roadmap
Teams that plan to use GPT-4o or Claude later hard-wire everything into the Gemini-only Interactions API, then face a costly re-platform.
✅
Fix: If multi-model is on the roadmap, keep LangGraph as the router and call the Interactions API as one node.
Migration is mostly about deleting code — the session-management and webhook plumbing that defined the Orchestration Tax era. Source
The best migration is the one where you delete more code than you write. If your Interactions API port added net lines, you migrated wrong.
What Most People Get Wrong About the Interactions API
The hot take is 'LangGraph is dead.' It isn't. What's dead is using a heavyweight orchestration framework to do single-vendor Gemini session management — a job the platform now does for free. LangGraph, AutoGen, and CrewAI still own the genuinely hard problem: coordinating heterogeneous agents across GPT-4o, Claude, and Gemini in one workflow. The Interactions API didn't kill orchestration frameworks; it commoditized the easy 80% and exposed the hard 20% as their real value. We cover that surviving niche in our agent frameworks comparison, and you can browse production-ready templates in our AI agents directory.
The post-Interactions stack: the platform owns state and orchestration, frameworks own cross-vendor routing, and your code owns business logic.
Average Expense to Use the Interactions API
Cost has three layers. First, token pricing — identical to standard Gemini model rates, confirmed at ai.google.dev/pricing. Second, a per-session state storage fee for keeping context server-side (the new line item — small per session, but it compounds at scale, which is why one-shot jobs should stay stateless). Third, Managed Agent sandbox compute for the remote Linux environment when you run agents like Antigravity.
Realistic total cost of ownership for a small business running a single multi-turn support agent: expect token costs in the low tens of dollars per month for modest volume, plus session-storage fees, minus the engineering hours you no longer spend building session and webhook infrastructure. That removed labor — easily 30–60% of an agent build per industry estimates — is where the real savings sit. A solo developer who would have spent two weeks on orchestration plumbing can now ship in days.
Good Practices and Pitfalls
Do: version-pin to the stable GA schema; use Search Grounding to cover the January 2025 knowledge cutoff; isolate untrusted code execution to Managed Agent sandboxes; reuse MCP tools across systems. Don't: route one-shot inference through stateful sessions; assume session state replaces retrieval; hard-wire Gemini-only if multi-vendor is on your roadmap; ignore the undated legacy deprecation — start your migration plan now while the 12-month-window precedent holds.
Frequently Asked Questions
What is the Interactions API for Gemini models and agents and how is it different from the previous Gemini API?
The Interactions API Gemini models agents endpoint is Google's primary unified surface for both Gemini models and agents, announced GA on June 23, 2026. The key difference from the legacy generateContent endpoint is server-side state: the model retains conversation context between turns, so you no longer re-send history on every call. It also adds native background execution (background=True), Managed Agents that run in secure Linux sandboxes, native MCP tool support, and multimodal handling for text, audio, video, and code under one schema. In short, it absorbs the orchestration plumbing — session management, tool routing, long-running jobs — that developers previously built themselves on top of the stateless API. Use it for multi-turn agents and background workflows; keep generateContent for one-shot, high-volume inference.
When did the Interactions API reach general availability and is it available globally?
The Interactions API reached general availability on June 23, 2026, per Google's official blog.google announcement. Its public beta launched in December 2025. There is no waitlist as of the GA date — any developer with a valid Gemini API key can access it via Google AI Studio or the Gemini API. Python, REST, and JavaScript/TypeScript SDKs all have confirmed parity. Apple developers can additionally call Gemini from Xcode via the Foundation Models framework integration announced the same week. Regional availability follows standard Gemini API availability; always verify your specific region's status in the official Google AI documentation, since rollout details and supported regions can change after a GA launch.
How do I migrate from the Gemini generateContent API to the Interactions API?
Start by identifying which calls actually need state. Migrate multi-turn and background workloads first; leave one-shot inference on generateContent. For a stateful flow, POST your first turn to /v1/interactions, capture the returned session_id, and on subsequent turns send only the session_id plus the new input — delete your client-side history-management code entirely. Re-register tools using the MCP schema standard so they're reusable. Move any custom webhook/queue system you built for long jobs to the native background=True flag. A correct migration usually removes more code than it adds. Google has not officially dated generateContent deprecation, but it historically gives ~12-month migration windows, so begin planning now. Pin to the stable GA schema to avoid surprises.
What are Managed Agents in the Interactions API and how do they work in practice?
Managed Agents let a single API call provision 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 custom agents with your own instructions, skills, and data sources. In practice you pass an agent ID instead of a model ID, often with background=True for long-running tasks. The sandbox is isolated cloud compute — Google's answer to the security risk of running agent code client-side. Cold start adds roughly 200–400ms per Google's documentation, which is negligible for multi-step research or data processing but matters for real-time voice. Early developer reports describe the isolation model as cleaner than OpenAI's Code Interpreter, though independent third-party audits are still pending.
Does the Interactions API support MCP tools and third-party integrations?
Yes. The GA release natively supports the Model Context Protocol (MCP), the open standard Anthropic pioneered in late 2024. This means tools built for any MCP-compatible system use the same schema and become reusable inside Gemini workflows without rewriting. You can mix MCP tools with first-party built-in tools — Google Search grounding, code execution — and your own custom function definitions in a single call. Google's native MCP adoption is a significant ecosystem validation that accelerates standardization across vendors. The practical advantage over OpenAI and Anthropic is first-party data depth: Search, Maps, YouTube, and Workspace tools are native, whereas competitors generally require third-party connectors. Register tools once per session and the model decides when to invoke them.
How does Google's Interactions API compare to OpenAI's Responses API and Assistants API?
OpenAI's Responses API introduced stateful runs in 2025, so Google reaches parity on core server-side state with the Interactions API GA, while leading on the stable, versioned schema commitment. OpenAI's Assistants API has shipped Managed Files and Code Interpreter since 2023, making Google's Managed Agents sandbox newer — but early developer reports call Google's isolation architecturally cleaner. The biggest practical differentiator is Google's vertical integration: Search Grounding, Maps, YouTube, and Workspace are first-party tools, while OpenAI relies on third-party connectors for comparable data access. Both support background/async execution and growing MCP compatibility. Choose based on your model preference and data sources: Gemini for Google-ecosystem depth, OpenAI for its mature assistants tooling and broader third-party connector marketplace.
Will using the Interactions API replace the need for LangGraph, AutoGen, or CrewAI in my Gemini projects?
For pure single-vendor Gemini workflows, largely yes — the Interactions API handles session state, tool routing, and background execution natively, which is exactly what you previously used LangGraph's StateGraph or AutoGen's ConversableAgent to do. But it does not replace these frameworks for multi-model orchestration. The Interactions API is Gemini-only; if your graph routes across GPT-4o, Claude 3.5 Sonnet, and Gemini, LangGraph remains your router. CrewAI and AutoGen also offer agent-to-agent communication patterns not yet exposed in Interactions API v1. The likely 2027 trajectory: frameworks reposition from single-model orchestrators to cross-vendor routers, calling the Interactions API as one node. Keep them if you need open-source portability or heterogeneous agent networks; drop them for Gemini-only builds.
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.
Top comments (0)