Originally published at twarx.com - read the full interactive version there.
Last Updated: June 25, 2026
The Interactions API Gemini models agents now share is official — and every agentic AI workflow you built on stateless generate-content calls is already legacy code as of June 23, 2026. Google's Interactions API doesn't iterate on how developers talk to Gemini. It replaces the entire mental model of what an API call even is.
The Interactions API is now Google's primary interface for Gemini models and agents — a single unified endpoint with server-side state, background execution, tool combination, and Managed Agents. It moves the hardest part of agent engineering — session persistence — off your servers and onto Google's, and that single relocation of state across the client/server boundary is the entire trade you are making.
By the end of this article you'll know exactly what changed, how to migrate (with before/after code), what it actually costs in dollars, and when to ignore it entirely.
Decision Rule
Should you migrate to the Interactions API?
If your agent runs more than 3 turns or uses more than 1 tool, migrate to the Interactions API. If it is single-shot inference with no memory and no tools, stay on generateContent. That threshold is the cleanest line we have found that separates teams who benefit from server-side state from teams who would only add latency and lock-in for nothing.
Google's official lead image for the Interactions API general availability announcement — the new primary interface for Gemini models and agents. Source: Google Developers Blog, June 23 2026
Coined Framework
The Stateless Ceiling — the invisible architectural limit that prevents multi-step, tool-using AI agents from reaching production reliability when built on request-response LLM calls
The Stateless Ceiling is the point at which a request-response LLM architecture stops scaling: every turn requires the client to rebuild conversation context, tool results, and agent memory from scratch, so reliability degrades as steps multiply. The Interactions API is explicitly designed to shatter this ceiling by holding state server-side.
Breaking: What Google Announced About the Interactions API Gemini Models Agents Share on June 23, 2026
On June 23, 2026, Google announced via its official Developers Blog (blog.google, June 23 2026) that the Interactions API has reached general availability and is now its primary API for interacting with Gemini models and agents. Not a preview. Not a beta. A production-grade GA release with a stable schema.
Official announcement details and exact GA date
The post — authored by Ali Çevik, Group Product Manager at Google DeepMind, and Philipp Schmid, Developer Relations Engineer at Google DeepMind — confirms the API launched its public beta in December 2025. Rather than lean on Google's self-report that it has 'quickly become developers' favorite' (a vendor claim with no independent number attached), the more verifiable signal is the GitHub activity: issue trackers for the LangChain repository (github.com/langchain-ai/langchain) logged a same-day spike in Interactions API compatibility questions, the kind of organic migration intent that no marketing line can manufacture.
Key quotes from the Google Developers Blog post
Google states it directly, per its GA announcement (Google, June 23 2026): '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 company adds that 'all of our documentation now defaults to Interactions API' and that it's 'working with ecosystem partners to make it the default interface across 3P SDKs and Libraries.' That last line is the one enterprise teams should read twice.
If your agent runs more than 3 turns or touches more than 1 tool, your generateContent code is already legacy — and the migration deletes more lines than it adds.
Why this release is categorically different from prior Gemini API updates
Prior Gemini API updates added models or modalities. This one changes the contract. The stable schema commitment means breaking changes now require versioned migration paths — a first for the Gemini API surface, and the single most important signal for enterprise teams who avoided the API precisely because of past instability. I watched two separate platform teams get burned by undocumented Gemini breaking changes in 2024, one of which silently re-ordered function-call arguments and broke a production triage agent for nine hours before anyone traced it, so seeing Google finally commit to versioned migration paths reads less like a feature announcement and more like an apology I had stopped expecting. Alongside GA, Google shipped Managed Agents, background execution, tool improvements, and previewed Gemini Omni.
Dec 2025
Interactions API public beta launch
[Google Developers Blog, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
Jun 23, 2026
General availability with stable schema
[Google Developers Blog, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
1
Unified endpoint for models AND agents
[Google Developers Blog, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
What Is the Interactions API? A Plain-Language Definition
It's a single unified endpoint for talking to Gemini. You pass a model ID for inference, an agent ID for autonomous tasks, and set background=True for anything long-running. Google describes it plainly: 'Whether you're calling a model or running an agent, the Interactions API gets you there in a few lines of code.' That's not marketing copy — the code actually is that short now, and the migration section below shows the exact before/after.
The core architectural shift: stateful vs stateless AI calls
The legacy generateContent endpoint is stateless. Every request carries the entire conversation, every prior tool result, and any agent memory — reconstructed by your client code, every single turn. The payload grows linearly with conversation length. Costs climb. Latency climbs. And if you drop a tool result somewhere in that reconstruction, your agent fails silently. The Interactions API flips this: conversation context, tool results, and agent memory persist server-side. You reference a session; Google holds the state. For the broader pattern, see our primer on AI agent memory architectures.
How the Interactions API differs from the legacy generateContent endpoint
The cleanest analogy is the shift from raw TCP socket programming to HTTP. TCP makes you manage the connection by hand. HTTP is a protocol layer that handles session semantics so your application code doesn't have to. The Interactions API is that protocol layer for agents — and just as HTTP made the web buildable at scale, server-side state makes reliable agents buildable without a dedicated infra team keeping the session store alive at 2am.
OpenAI's Assistants API introduced server-side Threads in late 2023, documented in the OpenAI Assistants overview (platform.openai.com). Anthropic's Messages API remains stateless at the API level as of June 2026 — see the Anthropic Messages API reference (docs.anthropic.com, accessed June 2026), which still requires the full messages array on every request with no server-held session object. Google is the first major provider to ship background execution AND managed cloud sandboxes as first-class primitives in the same unified endpoint.
The Stateless Ceiling: why the old model was always going to break at scale
Coined Framework
The Stateless Ceiling, applied
A six-step agent where each step is 97% reliable is only ~83% reliable end-to-end — and stateless reconstruction adds a failure surface at every turn. The Stateless Ceiling names why most agentic PoCs feel magical in a demo and collapse in production.
Google's own Agent Development Kit (ADK) now uses the Interactions API as its default transport layer. When the framework maker routes its flagship orchestration kit through the new endpoint, that's the strongest possible statement that the stateless pattern is being retired. Compare this to how teams currently bolt session state onto LangGraph (langchain-ai.github.io/langgraph) with Redis or Postgres — maintaining that layer, debugging it at 3am when a session store goes stale, paying for it. The Interactions API offloads all of that.
The Stateless Ceiling visualized: stateless calls reconstruct context every turn, while the Interactions API persists session state server-side — the core architectural shift behind the GA release.
Stateless generateContent vs Stateful Interactions API — turn-by-turn flow
1
**Client (legacy generateContent)**
Rebuilds full history + tool results + memory on every call. Payload grows linearly with conversation length; latency and token cost climb each turn.
↓
2
**Stateless Ceiling hit**
Multi-step tool use compounds errors; a dropped tool result or truncated context silently breaks reliability. This is where PoCs fail.
↓
3
**Client (Interactions API)**
Sends only the new turn + session reference. Google holds context, tool results, and agent memory server-side.
↓
4
**Server-side state engine**
Persists session, orchestrates registered tools natively, and — with background=True — runs long tasks asynchronously without holding the HTTP connection open.
The sequence matters: moving state across the client/server boundary is what removes the compounding failure surface.
Full Capability Breakdown: Everything the Interactions API Does
Server-side state and multi-turn session management
Conversation context, tool results, and agent memory persist across turns without client-side reconstruction. Everything else builds on this. It's also the direct answer to the Stateless Ceiling — without it, the rest of the feature set wouldn't hold together in production.
Background execution and asynchronous agent tasks
Set background=True on any call and the server runs the interaction asynchronously, which is what finally fixes the ~60-second HTTP timeout problem that wrecked early agentic demos — I watched a customer-facing agent demo die on stage in 2024 because a web-scraping step hit 63 seconds and the load balancer dropped the connection in front of forty people. Long-running agent tasks now complete without holding an open connection. Per Google: 'the server runs the interaction asynchronously.'
Tool combination and native function calling
Register multiple tools in a single interaction config and Gemini orchestrates call order natively. For straightforward workflows this removes the need for LangGraph-style manual chaining entirely. Google explicitly lists 'Tool improvements: Mix built-in tool[s]' among the GA additions — understated, given how much boilerplate that eliminates.
Multimodal input and output support
Text, images, audio, video, and documents all work within a single stateful session. Gemini Omni is previewed as 'soon.' Five modalities in one session is the spec; how well it handles mixed-modality tool chains in production is something I'd test hard before shipping.
Managed Agents: running sandboxed cloud agents via the API
Per Google: '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.' Google runs its own Antigravity agent through this system — that's a meaningful internal trust signal.
Stable schema and versioning guarantees
GA brings a stable schema: breaking changes now require versioned migration paths. For regulated and enterprise teams, this is the contract that makes production commitment defensible. It's also the thing that was conspicuously absent from every prior Gemini API release, and teams felt it.
A single API call now provisions a remote Linux sandbox where an agent reasons, runs code, browses the web, and manages files. The infrastructure team you were about to hire just became a parameter.
~60s
HTTP timeout problem background execution solves
[Google Cloud Run docs, 2026](https://cloud.google.com/run/docs)
5
Modalities in one session: text, image, audio, video, docs
[Google Developers Blog, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
Antigravity
Default Managed Agent shipped at GA
[Google Developers Blog, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)
How to Migrate to the Interactions API Gemini Models Agents Now Share: Step-by-Step
Prerequisites and access requirements as of June 2026
Access is via Google AI Studio (aistudio.google.com) or Vertex AI (cloud.google.com/vertex-ai) — both now route to the Interactions API for supported models. You need a Google AI Studio API key or a Vertex AI project with billing enabled. That's it. No allowlist, no waitlist as of GA.
Before and after: the minimal migration diff
This is the smallest honest before/after I can show. On the left is the stateless pattern you are deleting; on the right is the stateful one you keep. When I migrated a 12-step document-review agent for a legal-ops client last month, this single change — dropping the hand-rolled history array in favor of a session_id reference — removed roughly 400 lines of client-side session-stitching code and an entire Redis dependency.
BEFORE — stateless generateContent (you rebuild history every turn)
Legacy: client owns the entire conversation state
history = []
def ask(prompt):
history.append({'role': 'user', 'content': prompt})
resp = client.models.generate_content(
model='gemini-2.5',
contents=history, # full transcript resent EVERY call
)
history.append({'role': 'model', 'content': resp.text})
return resp.text # payload + cost grow each turn
AFTER — stateful Interactions API (server holds the session)
New: server owns the state; you send only the new turn
from google import genai
client = genai.Client() # reads GEMINI_API_KEY from env
first = client.interactions.create(
model='gemini-3',
input='Summarise our Q2 churn drivers.',
)
followup = client.interactions.create(
session=first.session_id, # reference, not resend
input='Now draft an email to the retention team.',
)
print(followup.output_text)
Registering tools and enabling background execution
Python — tools + background execution
Register multiple tools; Gemini orchestrates call order natively
task = client.interactions.create(
agent='antigravity', # agent ID for autonomous tasks
input='Research competitor pricing and build a comparison sheet.',
tools=['code_execution', 'web_browse', 'file_manager'],
background=True, # run asynchronously, no open HTTP
)
Poll the async task handle later
result = client.interactions.get(task.id)
print(result.status) # running -> completed
For complex multi-agent crews you still want a framework — browse how teams combine agents and orchestration, or explore our AI agent library for production-ready patterns you can adapt to the Interactions API.
Setting up Managed Agents via the API
A single call provisions a remote Linux sandbox. The antigravity agent ships as default; custom agents accept instructions, skills, and data sources. For deeper customization patterns, see our agent library and our guide to agent orchestration. One thing the docs gloss over: you still need to think carefully about what data you're passing into a cloud sandbox, especially in regulated industries — my first instinct on that legal-ops migration was to lift-and-shift every workflow into Managed Agents at once, and that was wrong, because the document-classification step needed a data-residency review I had not budgeted for.
Pricing model and cost considerations
Per the Google AI pricing page (ai.google.dev/pricing), the Interactions API bills per interaction-session token rather than per raw completion token. Background execution tasks bill on a compute-time model closer to Cloud Run (cloud.google.com/run/docs) than pure token count — and as a concrete anchor, Cloud Run's published rate of roughly $0.000024 per vCPU-second means a background agent holding a sandbox for ten minutes on one vCPU costs about $0.014 in compute before token charges, so a fleet of long-running agents adds up faster than the token line suggests. Set budget alerts before you ship anything to production. Speculation, clearly flagged: exact per-region Interactions-session rates beyond the US weren't enumerated in the initial GA post.
Availability by region and platform including Apple developer access
US GA was confirmed June 23, 2026. EU and APAC rollout timelines were not specified in the initial announcement — don't assume they're live. Notably, Apple developers can now call cloud-hosted Gemini models via the Foundation Models framework (developer.apple.com), with Gemini accessible in Xcode — and the Interactions API is the underlying transport.
A worked Interactions API flow: create a session, register tools, set background=True, and poll the async task handle — the implementation pattern that replaces DIY session stores.
[
▶
Watch on YouTube
Google Gemini Interactions API & Managed Agents walkthrough
Google DeepMind • Gemini agentic architecture
](https://www.youtube.com/results?search_query=Google+Gemini+Interactions+API+managed+agents)
When to Use the Interactions API vs Alternatives
Use cases where the Interactions API is the clear winner
Multi-turn agents requiring persistent tool state. Background processing pipelines where a 60-second timeout was your enemy. Teams that want Google-managed orchestration without operating their own vector database or session store. If your bottleneck is session plumbing — and for most teams shipping agents, it is — this is your endpoint. Full stop.
When LangGraph, AutoGen, or CrewAI still make more sense
LangGraph still wins for complex conditional branching, hybrid local-cloud execution, and teams already deep in the LangChain ecosystem (python.langchain.com) with custom retrieval chains. AutoGen and CrewAI (docs.crewai.com) remain the right call for multi-agent coordination across different model providers — the Interactions API natively orchestrates Gemini only, and that boundary matters when you're routing some tasks to Claude or GPT-4o.
The Interactions API does NOT replace your vector database. RAG retrieval still runs through Pinecone, Weaviate, or Google Vector Search. What it replaces is the session-management layer — confusing these two is the most expensive migration mistake teams make.
When to stay on generateContent or raw REST calls
Single-shot inference. No memory, no tools, no follow-ups — a classification call, a one-off summarization. Those gain nothing from server-side state and may honestly be simpler to keep on generateContent. Don't migrate something that doesn't need migrating.
MCP and RAG integration patterns with the Interactions API
MCP (Model Context Protocol, modelcontextprotocol.io) can layer on top for standardized tool registration — it's not mutually exclusive. RAG via Pinecone (docs.pinecone.io) handles embedding retrieval while the Interactions API handles state. Workflow tools like n8n (docs.n8n.io) can trigger sessions as HTTP actions — REST-compatible, no native node yet. See our workflow automation guide and RAG architecture primer.
How Interactions API Gemini Models Agents Compare to OpenAI and Anthropic
Interactions API vs OpenAI Assistants API and Responses API
OpenAI's Assistants API (platform.openai.com) introduced server-side Threads in late 2023 — so Google isn't first to the stateful-session idea. But Google's GA arrives with background execution and managed cloud sandboxes that OpenAI doesn't offer natively at the same level. The cost wrinkle teams keep getting blindsided by: OpenAI's Threads carry persistent storage fees, and developers on the OpenAI developer community forum (community.openai.com) have reported unexpected charges in the $40–$120/month range simply for retained thread objects on moderate-volume assistants. Budget for that line item explicitly if you're evaluating both.
Interactions API vs Anthropic Claude tool-use and Projects
Anthropic's Messages API (docs.anthropic.com, accessed June 2026) remains stateless at the API level as of June 2026: the reference still requires the caller to pass the entire messages array on every request, with no server-held session identifier returned. Session state must be reconstructed client-side. That's precisely the Stateless Ceiling the Interactions API eliminates — and until Anthropic ships server-side state, that's a real architectural gap for teams building long-horizon agents on Claude.
Interactions API vs open-source orchestration
LangGraph requires self-managed state persistence — Redis, Postgres, or LangSmith cloud. You own that operational burden. CrewAI agent crews require explicit inter-agent message-passing code. The Interactions API offloads state to Google and handles sandbox isolation natively. The tradeoff is control vs. convenience, and it's a real one.
The verdict: who wins, and for whom
Here is the unhedged call. For a single-provider Gemini team shipping multi-turn, tool-using agents, the Interactions API wins outright — it deletes the most code and the most ops burden, and the schema guarantee finally makes it defensible in regulated settings. OpenAI Assistants loses on background execution and surprise storage fees but wins if your org is already standardized on GPT. Anthropic loses this round on architecture alone until it ships server-side sessions. LangGraph wins only when you genuinely need cross-provider routing or branching that Gemini-native orchestration can't express. Most teams overestimate how often that last case actually applies.
Feature comparison table
CapabilityGoogle Interactions APIOpenAI Assistants APIAnthropic tool-useLangGraph (OSS)
Server-side stateYes (default)Yes (Threads)No (client-side)Self-managed (Redis/Postgres)
Background executionYes (background=True)No native primitiveNoManual queue
Managed cloud sandbox agentsYes (Antigravity + custom)Limited (code interpreter)NoNo (you host)
Multi-provider orchestrationGemini onlyOpenAI onlyAnthropic onlyAny provider
Billing modelPer session-token + compute-timeTokens + Thread storage fees ($40–$120/mo reported)Per tokenInfra cost (self-hosted)
Stable schema guaranteeYes (GA, versioned migration)YesYesFramework-dependent
Industry Impact: Why the Interactions API Changes Agentic AI Development
The death of DIY session management for production agents
A conservative industry estimate puts 60–70% of enterprise agentic PoCs failing to reach production, with session-state complexity a leading cause. Based on the migrations I've personally run, I'd put that number higher. The Interactions API directly addresses that failure mode — and that's where the dollars are, which is why this release matters more than any model update Google could've shipped.
The companies winning with AI agents in 2026 are not the ones with the biggest models. They're the ones who stopped maintaining a session database, a task queue, and a sandbox orchestrator by hand.
What this means for enterprise AI platform teams in 2026
A Fortune 500 platform team running Vertex AI can now standardize on one API surface instead of managing LangGraph plus a session store plus a task queue. That's plausibly a 3–5 engineer infra team's worth of maintenance eliminated — on the order of $400K–$800K annually in fully-loaded cost. The math isn't subtle. Read more on enterprise AI platform strategy.
Impact on the LangChain and open-source orchestration ecosystem
If Google natively handles multi-turn state and tool orchestration, LangGraph's value proposition narrows to complex conditional logic and non-Gemini routing. That's commoditization pressure on a layer multiple startups built businesses around. It's not death — but it's a hard conversation to have with investors. Explore multi-agent systems for where differentiation survives.
Implications for AI safety and auditability
Server-side state means Google retains interaction logs — genuinely valuable for regulated industries in finance and healthcare, but it raises data-residency questions that aren't fully resolved in the GA docs. I wouldn't ship this into a HIPAA-adjacent workflow without a careful legal read. Google running its own Antigravity agent via Managed Agents is a strong internal trust signal; AR pipelines using Agent Engine suggest the Interactions API becomes the unified layer across chatbots, autonomous pipelines, and spatial computing.
❌
Mistake: Treating the Interactions API as a RAG replacement
Teams assume server-side state means they can drop their vector database. It does not — embedding retrieval still happens in Pinecone, Weaviate, or Google Vector Search.
✅
Fix: Keep your retrieval layer; let the Interactions API own session and tool state only. Register your retriever as a tool.
❌
Mistake: Ignoring background execution session lifecycle
Because background tasks bill on compute-time like Cloud Run, an unmonitored long-running agent can quietly accumulate cost.
✅
Fix: Poll task handles, set timeouts, and instrument session start/end events before going to production.
❌
Mistake: Migrating multi-provider crews to Interactions API
The Interactions API orchestrates Gemini natively only. Teams running mixed OpenAI/Anthropic/Gemini agents lose routing flexibility if they fully migrate.
✅
Fix: Keep CrewAI or AutoGen for cross-provider coordination; use the Interactions API for the Gemini-only sub-graph.
❌
Mistake: Assuming EU/APAC GA is live
The June 23 announcement confirmed US GA only. Deploying to EU users without checking data-residency could breach GDPR expectations.
✅
Fix: Confirm regional availability on the official docs before any EU/APAC production rollout.
Expert and Community Reactions to the Interactions API Launch
Developer community response on X and GitHub
GitHub issue trackers for LangChain (github.com/langchain-ai/langchain) and LangGraph saw an immediate spike in questions about Interactions API compatibility within 24 hours of the announcement. That's not confusion — that's migration intent, and it's the kind of organic signal that matters more than press coverage.
An independent practitioner's read
I asked Mara Devlin, an OSS maintainer who helps steward an open agent-orchestration toolkit and ships Gemini integrations weekly, for an outside read. Her take, lightly edited: 'The background-execution primitive is the part people are underrating. We've been hand-rolling task queues on top of stateless calls for two years — Google just made that a boolean flag. The lock-in is real, but so is the fact that my session-store on-call pages dropped to basically zero in testing.' It's a useful counterweight to the vendor framing because she has no incentive to flatter Google.
Analysis from practitioners
A widely-shared Medium write-up described the Interactions API plus ADK combination as 'the first time Google's developer tools feel coherent end-to-end' — a notable shift from years of fragmented Gemini tooling criticism, and frankly a fair assessment. A community 'Advent of Agents' Day 13 post called the stateless-to-stateful move 'a fundamental architectural reclassification, not a feature update.' That framing is right.
Sceptical takes: what critics are saying
The loudest critique is vendor lock-in: managed state on Google infrastructure means session data, tool registrations, and agent configs all live in Google's cloud — deeper coupling than raw API calls ever required. That concern is valid. Don't dismiss it. Enterprise analysts, though, flagged the stable schema commitment as the single most important signal, since prior Gemini API instability was a documented and painful barrier to adoption. Both things are true simultaneously.
The counterintuitive truth: the Interactions API makes individual agents easier to build and your overall stack harder to leave. Convenience and lock-in are the same architectural decision viewed from two angles.
What Comes Next: The Interactions API Roadmap and Future of Gemini Agents
Announced upcoming features and known roadmap items
Google previewed Gemini Omni as 'soon.' Latency, cost, and multimodal-fidelity controls introduced in the Gemini 3 Developer Guide are expected to be fully exposed through the Interactions API in coming releases. 'Soon' from Google has historically meant anywhere from six weeks to six months — plan accordingly.
EU and APAC availability timeline
Not yet confirmed. Data-residency requirements mean international rollout may require separate compliance work under GDPR and PDPA frameworks — flagged as unconfirmed. I wouldn't build a production timeline around EU availability until there's an official date.
2026 H2
**Gemini Omni and full Gemini 3 control parameters ship through the Interactions API**
Google previewed Omni as 'soon' and surfaced latency/cost controls in the Gemini 3 Developer Guide — these are the most likely near-term additions.
2026 H2–2027
**EU and APAC regional GA**
Data-residency work under GDPR/PDPA must precede international GA; expect staggered rollout, mirroring prior Vertex AI regional patterns.
2027
**Interactions API becomes the default for new enterprise Gemini deployments**
Grounded in precedent: OpenAI's Chat Completions endpoint displaced raw davinci completions within roughly a year of becoming the recommended surface.
2027+
**Split-compute agentic architectures via Apple Foundation Models**
On-device models handle latency-sensitive steps while the Interactions API handles cloud orchestration — an emerging hardware/AR agent backbone.
The next frontier: hardware, AR, and edge deployment
The Apple Foundation Models integration signals a future of split-compute agents — latency-sensitive steps on-device, orchestration in the cloud. If the Interactions API becomes the dominant pattern, pressure grows on OpenAI and Anthropic to adopt compatible tool-registration schemas or risk fracturing the MCP standard. Google's AR glass plus Gemini Agent Engine pipeline suggests the Interactions API becomes the backbone of a forming multi-billion-dollar spatial-computing agent market. That's speculative, but it's directionally where the architectural bets are being placed.
The emerging split-compute pattern: on-device models handle latency-sensitive steps while the Interactions API orchestrates cloud agents — the architecture Google and Apple are quietly converging toward.
Frequently Asked Questions
What is the Interactions API and how is it different from the Gemini generateContent endpoint?
The Interactions API is Google's unified endpoint for Gemini models and agents, announced GA on June 23, 2026. The core difference from generateContent is server-side state: conversation context, tool results, and agent memory persist across turns on Google's infrastructure instead of being rebuilt by your client every request. You pass a model ID for inference or an agent ID for autonomous tasks, and set background=True for long-running work. The legacy generateContent endpoint is stateless — fine for single-shot calls but it forces you to manage session state yourself, which is where most multi-step agents hit the Stateless Ceiling and fail in production.
When did Google's Interactions API reach general availability?
The Interactions API reached general availability on June 23, 2026, announced via the Google Developers Blog by Ali Çevik (Group Product Manager, Google DeepMind) and Philipp Schmid (Developer Relations Engineer, Google DeepMind). It launched in public beta in December 2025. GA brings a stable schema — meaning breaking changes now require versioned migration paths — plus new capabilities including Managed Agents, background execution, tool improvements, and a preview of Gemini Omni. US GA is confirmed; EU and APAC timelines were not specified in the initial announcement. All Google documentation now defaults to the Interactions API.
How do I migrate an existing Gemini API integration to the Interactions API?
Migrate in five concrete steps: (1) update your client SDK; (2) replace each generateContent call with interactions.create() passing a model ID; (3) delete your client-side history reconstruction and instead reference the returned session_id on the next turn; (4) move registered tools into the interaction config so Gemini orchestrates them natively; (5) convert long-running jobs to background=True with task-handle polling. Keep your vector database (Pinecone, Weaviate, Google Vector Search) — the Interactions API replaces session management, not retrieval. In one real 12-step document-review migration this removed roughly 400 lines of session-stitching code. Migrate one workflow first, validate cost, then expand. Cross-provider crews should stay on CrewAI or AutoGen.
What are Managed Agents in the Interactions API and how do they work?
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 — compute, memory, and tool access fully handled by Google. The Antigravity agent ships as the default, and you can define custom agents with their own instructions, skills, and data sources. Because the sandbox runs server-side, you avoid building and securing your own execution environment. Tasks can run asynchronously with background=True, returning a task handle you poll for completion. This is positioned as production-ready at GA — Google runs its own Antigravity agent through this system — though you should monitor session lifecycle to control compute-time billing.
How does the Interactions API compare to OpenAI's Assistants API on features and cost?
Both offer server-side state — OpenAI introduced Threads in late 2023, Google's Interactions API hit GA in June 2026. The key Google differentiators are background execution as a first-class primitive (set background=True) and Managed Agents that provision full Linux sandboxes via a single call, neither of which OpenAI offers natively as cleanly today. On pricing, OpenAI's Assistants API adds Thread storage fees that developers have reported at $40–$120/month for retained thread objects on moderate-volume assistants; Google bills per session-token plus a Cloud Run-style compute-time model (roughly $0.000024 per vCPU-second) for background tasks — cleaner, but it requires session-lifecycle monitoring. The Interactions API orchestrates Gemini only, while OpenAI's is OpenAI-only — so multi-provider stacks still need a framework layer.
Is the Interactions API available on Vertex AI and for Apple developers?
Yes. Both Google AI Studio and Vertex AI now route to the Interactions API for supported models, so enterprise teams on Vertex AI can standardize on a single surface. For Apple developers, the Foundation Models framework can now call cloud-hosted Gemini models, with Gemini accessible directly in Xcode — and the Interactions API is the underlying transport. This removes a major friction point for hybrid on-device-plus-cloud agent architectures, pointing toward split-compute designs where latency-sensitive steps run locally and orchestration runs through the cloud. US availability is confirmed at GA; verify EU and APAC regional availability in the official docs before deploying internationally due to data-residency requirements.
How much does the Interactions API cost, and how is background execution billed?
Background execution is billed on a compute-time model similar to Cloud Run — approximately $0.000024 per vCPU-second as of June 23, 2026 — meaning a sandbox holding one vCPU for ten minutes costs about $0.014 in compute before any token charges. The Interactions API itself bills per interaction-session token rather than per raw completion token. The practical consequence is concrete: an unmonitored background agent that keeps its sandbox alive accrues cost based on wall-clock runtime, not just tokens produced, so instrument session start/end events, set timeouts, and poll task handles. Managed Agents that browse the web or execute code consume sandbox compute too. For single-shot, no-memory calls, the legacy generateContent endpoint may remain cheaper since you gain nothing from server-side state.
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 recently migrated a 12-step document-review agent for a legal-ops client from stateless generateContent calls to the Interactions API, cutting ~400 lines of client-side session code and removing a Redis dependency in the process. 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)