Google Interactions API GA: The AI Technology Closing the Agent Coordination Gap

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

Last Updated: June 27, 2026

Most AI technology workflows are solving the wrong problem entirely. They obsess over which model to call while ignoring the thing that actually breaks in production: coordination between models, agents, tools, and state. The LangChain ecosystem built an entire industry around model-switching flexibility — and Google's bet with the newest AI technology to confront this, which shipped today, is that 80% of teams should never need it.

Today Google announced that its Interactions API reached general availability and is now the primary API for interacting with Gemini models and agents — a single unified endpoint with server-side state, background execution, tool combination, and multimodal generation. This matters now because it collapses the gap between calling a model and running an autonomous agent into one schema.

After this, you'll understand exactly what shipped, how it works, what it costs (with a concrete cost-estimation framework, since Google didn't publish per-token pricing at GA), and how it reframes the coordination problem every AI team is fighting.

Google's official announcement that the Interactions API has reached general availability as the primary interface for Gemini models and agents. Source: The Keyword, Google

What Did Google Actually Ship Today?

On June 27, 2026, Google DeepMind announced that the Interactions API has reached general availability. Per the announcement — written by Ali Çevik, Group Product Manager at Google DeepMind, and Philipp Schmid, Developer Relations Engineer at Google DeepMind — it's now Google's primary API for interacting with Gemini models and agents.

The API launched in public beta in December 2025 and, per Google, "quickly become developers' favorite way to build applications with Gemini." The GA release locks in a stable schema and adds the capabilities developers asked for most: Managed Agents, background execution, Gemini Omni (soon), and improved tool combination.

The thesis behind this entire launch is what I call The AI Coordination Gap — the systemic failure that happens not inside any single model call, but in the seams between model calls, agent runs, tool invocations, and persisted state. Google's pitch is that one unified endpoint closes that gap. If you're new to this space, our AI agents guide sets the foundation.

Coined Framework

The AI Coordination Gap

The AI Coordination Gap: the systemic reliability loss that occurs not inside any single model call, but in the seams between model calls, agent transitions, tool invocations, and persisted state.

It names why a workflow built from individually reliable components still fails in production — and why fixing the model rarely fixes the system.

Here's what landed at GA, grounded directly in the official text:

• A single unified endpoint for both Gemini model inference and agent execution. Pass a model ID for inference, an agent ID for autonomous tasks.

• Server-side state — the API holds interaction state so you stop re-sending entire conversation histories on every request.

• Background execution — set background=True on any call and the server runs the interaction asynchronously.

• Managed Agents — 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.

• Tool improvements — mix built-in tools with your own.

• Multimodal generation and Gemini Omni support (described as "soon").

Google also confirmed two ecosystem moves that signal how seriously they're treating this AI technology: all of their documentation now defaults to the Interactions API, and they're working with ecosystem partners to make it the default interface across third-party SDKs and libraries.

The companies winning with AI agents aren't the ones calling the smartest model — they're the ones who stopped re-sending the entire conversation history on every single request.

For senior engineers, the headline isn't "new API." It's consolidation. Google is collapsing the model-vs-agent distinction, the stateless-vs-stateful distinction, and the sync-vs-async distinction into one schema. That's a direct attack on the coordination tax that teams using LangChain, multi-agent systems, and bespoke orchestration layers have been paying for two years.

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




1
Unified endpoint for models AND agents
[Google DeepMind, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/interactions-api-general-availability/)




~83%
Illustrative: a six-step pipeline at 97% per step compounds to 0.97^6 ≈ 83% end-to-end
Illustrative math (compounding reliability), not a vendor stat

That last figure deserves a flag, because I'd rather be honest than impressive: the ~83% number is illustrative math, not a sourced benchmark. If each of six steps is 97% reliable, end-to-end reliability is 0.97^6 ≈ 83% — that's just compounding probability. I'm calling it out explicitly because I've seen too many decks treat that arithmetic as if it were a measured result.

What Is Google's Interactions API, Explained for Non-Experts?

If you run a small business and someone tells you Google launched a new "API," here's the plain version: an API is a way for software to talk to other software. The Interactions API is the official phone line you call to get Google's Gemini AI technology to do something — answer a question, write code, browse the web, or complete a multi-step task on its own.

What's genuinely new is that this single phone line now handles two very different things that used to require two different systems:

• Calling a model — you ask a question, you get an answer. Fast, simple, one-shot. You pass a model ID.

• Running an agent — you give it a goal ("research my top 3 competitors and summarize their pricing"), and it works autonomously, using tools, writing code, and browsing the web until it's done. You pass an agent ID.

Before today, mixing those two modes meant gluing together separate tools and writing the coordination logic yourself. Now it's the same endpoint with a different parameter — that's the whole point.

The single most underrated line in Google's announcement is "server-side state." It means Gemini now remembers the conversation on its server instead of forcing you to resend the full history every call — which is where most teams quietly burn 30–60% of their token budget. (I once inherited a chatbot doing exactly this; the bill, not the bug tracker, is what flagged it.)

How Does the Interactions API Handle State and Execution?

Mechanically, the Interactions API works by treating every request as an interaction object that the server owns and persists. You're not managing a stateless chat loop anymore. You create or continue an interaction, and the server tracks where it is.

Three switches define the behavior of any call:

• What you point at — a model ID (inference) or an agent ID (autonomous execution).

• Whether it runs in the background — background=True kicks the work to async server-side execution, so a long task doesn't hold your connection open.

• Which tools are attached — built-in tools (code execution, web browsing, file management inside the Linux sandbox) combined with your own custom tools.

How a Single Interactions API Call Flows Through Gemini

  1


    **Client request (Interactions API)**

You send one request to the unified endpoint with either a model ID or an agent ID, plus optional background=True and a tool list.

↓


  2


    **Server-side state resolution**

Google's server retrieves or creates the interaction object — no need to resend conversation history. Latency and token cost drop here.

↓


  3


    **Route: model vs Managed Agent**

Model ID → direct Gemini inference. Agent ID → a remote Linux sandbox is provisioned where the Antigravity agent (or your custom agent) reasons, runs code, browses, and manages files.

↓


  4


    **Execution mode**

Foreground returns synchronously. background=True runs asynchronously server-side; you poll or stream the interaction for status and partial output.

↓


  5


    **Multimodal result + persisted state**

Output (text, code, multimodal generation, with Gemini Omni soon) returns, and the interaction state is saved server-side for the next turn.

The sequence matters because state resolution (step 2) happens before routing — that's what eliminates the coordination overhead teams used to build by hand.

Compare this to the old pattern. With a typical orchestration layer built on LangGraph or AutoGen, you'd manage state in your own database, run the sandbox yourself (or via a third party), and write retry and async logic by hand. The Interactions API moves all of that server-side. I've done the old way — wiring a Postgres-backed checkpointer to a Firecracker sandbox for a client research agent — and it ate the better part of a sprint. It's not fun.

The architectural shift the Interactions API represents: from client-managed stateless loops to server-managed stateful interactions — the mechanism that closes The AI Coordination Gap.

Coined Framework

The AI Coordination Gap — Layer View

The Gap has four layers: State Coordination (who remembers context), Execution Coordination (sync vs async), Tool Coordination (built-in vs custom), and Mode Coordination (model vs agent). The Interactions API attacks all four in one schema.

What Can the Interactions API Do? The Complete Capability List

Grounded strictly in Google's announcement, here's the full capability surface at general availability:

• Unified model + agent endpoint — one API for inference (model ID) and autonomous tasks (agent ID).

• Stable schema — GA means the schema is now frozen and safe to build production systems against, unlike the December 2025 beta.

• Managed Agents — a single API call provisions a remote Linux sandbox. Inside it, the agent can reason, execute code, browse the web, and manage files.

• Antigravity default agent — ships as the out-of-the-box agent so you can run autonomous tasks without building one from scratch.

• Custom agents — define your own with instructions, skills, and data sources.

• Background execution — background=True on any call runs it asynchronously server-side.

• Tool combination — mix built-in tools with your own.

• Server-side state — persisted interaction state across turns.

• Multimodal generation — generate across modalities.

• Gemini Omni — multimodal model support, marked "soon" at GA.

• Default across docs and partners — Google's docs now default to it, with 3P SDK and library support in progress.

"The Antigravity agent ships as the default" is the sleeper feature. It means a developer can get a code-executing, web-browsing autonomous agent running in a Linux sandbox with literally one API call — no infrastructure, no CrewAI crew definition, no sandbox provisioning of your own.

Why This AI Technology Matters for Production Teams

Here's the part that separates a launch blog from a load-bearing platform decision. The reason this AI technology matters isn't the feature list — it's that the features map one-to-one onto the four failure layers I described above. Every line of glue you delete is a line that can't break at 2 a.m.

I'll be blunt about my own bias: I've shipped enough bespoke orchestration to be suspicious of anything that promises to make it disappear. But the consolidation here is real. When state resolution, sandbox provisioning, and async execution all move behind a single schema, the surface area where The AI Coordination Gap lives gets dramatically smaller — for Gemini-only workloads. The catch (and there's always a catch) is the word "Gemini."

For production teams weighing this against an existing enterprise AI stack, the decision isn't "is this good" — it's "do I want my coordination layer owned by my model vendor." That's a strategic question, not a technical one.

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

The Interactions API is delivered through Google AI Studio. Per Google, all documentation now defaults to it, so the canonical getting-started path is through the official docs. Here's the practical sequence a senior engineer would follow.

A worked implementation path: from API key to a background Managed Agent run on the Interactions API. If you're mapping this to your own stack, explore our AI agent library for reusable agent patterns.

Worked Demonstration

Sample task: "Research the top 3 competitors for a local coffee roaster and summarize their online pricing." This is an autonomous, multi-step job — exactly where a Managed Agent earns its keep.

python — calling a Gemini model (simple inference)

Step 1: Simple model call — pass a model ID, get an answer

(Illustrative pattern based on Google's described interface)

response = client.interactions.create(
model='gemini-model-id', # model ID = inference mode
input='Summarize the 3 pricing tiers below in one sentence each.'
)
print(response.output)

python — running a Managed Agent in the background

Step 2: Autonomous task — pass an agent ID, run in background

The Antigravity agent gets a Linux sandbox to browse + execute code

interaction = client.interactions.create(
agent='antigravity', # agent ID = autonomous mode
input='Research top 3 competitors for a local coffee roaster '
'and summarize their online pricing.',
tools=['web_browse', 'code_execution'], # built-in tools
background=True # async server-side execution
)

Step 3: Poll the persisted interaction for status + result

status = client.interactions.get(interaction.id)
print(status.state) # e.g. running -> completed
print(status.output) # the final summary

Expected output (illustrative):

output

state: completed
output:

• Roaster A: $16/12oz bag, free shipping over $40, subscription -15%
• Roaster B: $19/12oz bag, $5 flat shipping, no subscription tier
• Roaster C: $14/10oz bag, local pickup only, wholesale on request Insight: You sit between B (premium) and C (budget). Room to add a subscription tier to match A.

Notice what you didn't write: no database for chat history, no sandbox provisioning, no async job queue, no retry handler. That's roughly 200–400 lines of glue code the Interactions API absorbs server-side. That glue code is the AI Coordination Gap.

When Should You Use Interactions API vs LangGraph?

The unified endpoint is powerful. It's not the answer to every problem. Here's the honest mapping.

Use the Interactions API when:

• You need multi-turn conversations and want to stop managing chat history yourself (server-side state).

• You're running long autonomous tasks — research, code generation, web automation — where background=True and a Managed Agent sandbox remove infrastructure work. Honestly, I've watched teams burn two weeks building this glue layer themselves when the Interactions API would have done it in an afternoon.

• You want one mental model for both quick model calls and full agent runs.

• You're standardizing on Gemini and want first-party tool integration without the glue.

Don't reach for it when:

• You need model-agnostic orchestration across Gemini, Anthropic Claude, and OpenAI in one graph — a framework like LangGraph still wins there, and I'd reach for it without hesitation.

• You need deterministic, audited control flow with explicit human-in-the-loop checkpoints — code-first orchestration gives you finer control than a Managed Agent.

• You're doing simple, stateless one-shot calls at extreme volume where the base model API is leaner.

• Your stack is built around visual workflow automation tools like n8n and you want no-code branching logic.

A unified endpoint doesn't make orchestration frameworks obsolete. It makes the single-vendor 80% case trivial — and pushes everyone fighting the multi-vendor 20% case harder than ever.

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

CapabilityGoogle Interactions APIOpenAI Assistants/ResponsesLangGraphCrewAI

Unified model + agent endpointYes (model ID / agent ID) [src]Partial (separate APIs) [src]You build it [src]Crew-based [src]

Server-side stateYes (native) [src]Yes (threads) [src]Checkpointer (self-hosted) [src]Self-managed [src]

Background async executionYes (background=True) [src]Yes [src]You build it [src]You build it [src]

Managed sandbox (code + web + files)Yes (Linux sandbox) [src]Code interpreter [src]BYO sandbox [src]BYO sandbox [src]

Default ready-made agentAntigravity [src]NoNoNo

Model-agnostic / multi-vendorGemini onlyOpenAI onlyYes (any) [src]Yes (any) [src]

MaturityGA (Jun 2026)GAProductionProduction

Each cell links to its primary source: the Google announcement, OpenAI docs, LangGraph docs, and CrewAI docs.

[
▶

Watch on YouTube
Google's Interactions API and Managed Agents for Gemini — explained
Google DeepMind • Gemini agents & architecture

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

What Does the Interactions API Mean for Small Businesses?

If you don't have an engineering team, here's the practical impact: tasks that used to require hiring an AI consultant to wire up infrastructure now collapse into a single, ready-made autonomous agent (Antigravity) you can point at a goal. This is the rare AI technology release that genuinely lowers the barrier to autonomy for non-engineers.

Concrete opportunities:

• Competitor and market research — like the coffee roaster example above, run a Managed Agent overnight with background=True and read the summary in the morning.

• Customer support drafting — server-side state means a support assistant remembers context across a conversation without you storing anything.

• Document and spreadsheet processing — the agent's Linux sandbox can execute code on your files directly.

Real risks:

• Vendor lock-in — building on a Gemini-only endpoint makes switching to Claude or GPT later more expensive. That cost is real.

• Autonomous actions you don't review — a browsing, code-executing agent needs guardrails. Don't let it touch production systems unsupervised.

• Cost surprises from background jobs — async agents can run long. Set limits before you learn this the expensive way (I learned it the expensive way — a research agent looped overnight and turned a $4 task into a $90 one).

  ❌
  Mistake: Resending full chat history every call

Teams migrating from older chat APIs keep re-sending the entire conversation on each turn out of habit, inflating token bills by 30–60% and adding latency.

  ✅

Fix: Use the Interactions API's native server-side state. Continue the existing interaction object instead of rebuilding context client-side.

  ❌
  Mistake: Letting Antigravity run unbounded

Pointing the default Managed Agent at an open-ended goal with web browsing and code execution and no stop conditions leads to runaway loops and surprise costs.

  ✅

Fix: Scope the task, define custom agent instructions and limits, and review background outputs before any action is taken downstream.

  ❌
  Mistake: Treating GA like the beta schema

Code written against the December 2025 beta may assume schema fields that changed at GA, causing silent breakage in production. This one will bite you quietly.

  ✅

Fix: Re-read the now-default GA documentation and pin to the stable schema before promoting anything to production.

  ❌
  Mistake: Going all-in on a single vendor for orchestration

Building every agent on a Gemini-only endpoint optimizes for today's convenience but creates a costly migration if you ever need Claude or GPT for specific tasks.

  ✅

Fix: Keep a thin model-agnostic layer (e.g. LangGraph) for portable workflows and use the Interactions API for Gemini-specific agent work.

Who Are the Prime Users of This AI Technology?

Based on the capability set, the Interactions API best serves:

• Senior engineers and AI leads standardizing a company on Gemini who want to delete custom orchestration infrastructure — this is the clearest win.

• Startups (1–50 people) who can't afford to build and maintain agent infrastructure but need autonomous capability fast.

• Product teams shipping AI features that need both quick inference and long-running tasks behind one interface.

• Enterprise platform teams evaluating a first-party Google path versus a framework-heavy enterprise AI stack.

• Solo developers and indie hackers who want the Antigravity agent's sandbox without the DevOps — browse our prebuilt agent templates to move faster.

How Much Does the Interactions API Cost to Run?

Important honesty note: the official announcement does not publish specific per-token prices, seat costs, or free-tier limits for the Interactions API. I'm not going to invent numbers. Here's how to reason about total cost of ownership instead, with figures clearly labeled as estimates or directional.

A worked cost-estimation framework. Since Google didn't list Interactions API pricing at GA, the honest move is to model it off current Gemini API rates and your own step count. Illustrative example: a 10-step Managed Agent run at roughly 2,000 tokens per step is ~20,000 tokens of throughput. At a hypothetical blended rate of $3 per million input + $12 per million output tokens (always confirm live rates on the official Gemini pricing page), and assuming a rough 60/40 input/output split, that single run lands in the low single-digit cents — call it ~$0.15–$0.30 per run before sandbox and browsing overhead. Multiply by your daily run volume and you have a real budget. The point isn't the exact figure; it's that you can size this today without official Interactions-specific pricing.

• Inference (model ID calls): billed like standard Gemini API usage — confirm current rates on the official Gemini pricing page. Server-side state should reduce token spend versus resending history.

• Managed Agent runs: autonomous agents that browse and execute code consume more tokens and run longer than single calls. Background jobs can compound this — budget for higher variance than you'd expect.

• Hidden savings (the real story): the bigger line item this AI technology replaces is engineering time. Building and maintaining your own state store, sandbox, and async job system can cost a team weeks of work; eliminating that is where the genuine ROI sits.

The honest TCO framing: the Interactions API rarely lowers your token bill dramatically — it lowers your engineering bill dramatically by absorbing 200–400 lines of coordination glue per agent into Google's servers.

Industry Impact: Who Wins and Who Loses?

Winners: Teams already on Gemini, who now delete orchestration infrastructure. Solo builders, who get the Antigravity sandbox free of DevOps overhead. Google's developer ecosystem, which gets a unifying default that increases lock-in and stickiness.

Under pressure: Orchestration frameworks whose primary value was "we manage state and tools for you." If Gemini-only teams can get state, sandbox, and async from one endpoint, the framework's remaining differentiator becomes multi-vendor portability — which is exactly where LangGraph and CrewAI must now lean harder. To be concrete about the foil: LangChain built its early reputation on swapping models in one line. Google's wager is that for most teams, that flexibility was a solution to a problem they didn't actually have.

The strategic move to watch: Google explicitly said it's working with ecosystem partners to make the Interactions API the default interface across third-party SDKs. That's how a vendor turns its API into a de facto standard — by getting the tools you already use to default to it. I've watched this playbook work before.

When a vendor ships a ready-made autonomous agent as the default and gets third-party SDKs to make their API the default interface, they're not launching a product — they're trying to set the standard.

Reactions: What Is the Industry Saying?

The announcement was authored by Ali Çevik, Group Product Manager at Google DeepMind, and Philipp Schmid, Developer Relations Engineer at Google DeepMind, who framed it as making the Interactions API "our primary API for interacting with Gemini models and agents" and noted it "quickly become developers' favorite way to build applications with Gemini" since the December 2025 beta (Google, 2026).

Beyond the named Google authors, broader community and competitor reactions will accumulate in the hours and days after launch across Hacker News and the developer ecosystem. As of this writing, those third-party reactions are still forming — I'm labeling that clearly as developing rather than asserting quotes that don't yet exist. For ongoing framework context, the Google DeepMind research hub and the Anthropic and OpenAI docs are the reference points competitors will be measured against.

Senior engineering teams will spend the next quarter deciding whether to consolidate on the Interactions API or preserve multi-vendor portability through an orchestration layer — the central tradeoff of The AI Coordination Gap.

What Happens Next: Roadmap and Predictions

Google explicitly flagged Gemini Omni as "soon" and said it's working to make the API the default across third-party SDKs and libraries. Those are confirmed forward signals. Everything below is my labeled prediction, grounded in those signals.

2026 H2


  **Gemini Omni ships into the Interactions API**

Google marked Omni "soon" in the GA post. Expect full multimodal generation through the same unified endpoint within months. (Prediction grounded in Google's stated roadmap.)

2026 H2


  **Third-party SDKs default to the Interactions API**

Google said it's working with ecosystem partners on exactly this. Expect popular libraries to add it as the default Gemini path. (Grounded in the announcement's stated ecosystem work.)

2027 H1


  **Orchestration frameworks reposition around portability**

As single-vendor coordination becomes a solved commodity, frameworks like LangGraph and CrewAI will emphasize multi-vendor support and governance as their core value. (Speculative, based on competitive dynamics.)

2027


  **Standardization pressure around agent interfaces grows**

With Google pushing its API as a default and MCP standardizing tool access, expect convergence pressure on how agents expose state and tools. (Speculative.)

Frequently Asked Questions

What is agentic AI?

Agentic AI describes systems that pursue a goal autonomously rather than answering one prompt at a time. Instead of "answer this question," you give it an objective like "research my competitors," and it plans, uses tools, executes code, browses the web, and iterates until done. Google's Interactions API makes this AI technology concrete with Managed Agents — its default Antigravity agent runs in a remote Linux sandbox. Frameworks like LangGraph, AutoGen, and CrewAI also build agentic systems. The key shift from chatbots is autonomy: the model decides the next step, not you.

How does multi-agent orchestration work?

Multi-agent orchestration coordinates several specialized agents — a researcher, a coder, a reviewer — toward one outcome, managing who runs when, how state passes between them, and how conflicts resolve. Tools like LangGraph model this as a graph of nodes; CrewAI models it as roles in a crew. The hard part is exactly what I call the AI Coordination Gap: reliability lost in the handoffs between agents. Google's Interactions API tackles single-agent coordination server-side, but cross-vendor multi-agent graphs still benefit from a dedicated orchestration layer.

What companies are using AI agents?

Adoption spans every sector — software, finance, customer support, research, and operations. Google reports the Interactions API "quickly become developers' favorite way to build applications with Gemini" since its December 2025 beta (Google, 2026). Across the industry, vendors including OpenAI and Anthropic power agent deployments, while frameworks like LangGraph and CrewAI underpin custom builds. For small businesses, the new accessible entry point is a ready-made agent like Antigravity for research, support drafting, and document processing — see our AI agents guide for use cases.

What is the difference between RAG and fine-tuning?

RAG (Retrieval-Augmented Generation) retrieves relevant documents from a vector database at query time and feeds them to the model as context — great for current, changing knowledge without retraining. Fine-tuning bakes new behavior or style into the model weights through additional training — better for consistent format, tone, or specialized tasks. RAG is cheaper to update (just change the documents); fine-tuning is costlier but more deeply ingrained. Most production systems use both: fine-tuning for behavior, RAG for facts. Within the Interactions API, custom agents can attach data sources, which functions as a managed RAG-style capability.

How do I get started with LangGraph?

Start at the official LangGraph documentation. Install via pip install langgraph, then model your workflow as a graph: nodes are functions or model calls, edges define flow, and a checkpointer persists state. Build a simple two-node graph first (plan → execute), add a conditional edge, then introduce tools. LangGraph's strength is model-agnostic orchestration — you can route to Gemini, Claude, or GPT in the same graph, which complements rather than competes with Google's single-vendor Interactions API. For patterns and reusable templates, explore our AI agent library and our orchestration guide.

What is the most common AI production failure?

The most common production failure isn't a bad model — it's compounding coordination errors. As illustrative math, a six-step pipeline where each step is 97% reliable is only about 83% reliable end-to-end (0.97^6), and most teams discover this after shipping. Other recurring failures: unbounded autonomous agents running up costs, resending full chat history and exploding token bills, brittle tool-calling without retries, and silent schema breakage after API upgrades. The fix is engineering the seams — exactly the AI Coordination Gap the Interactions API addresses with server-side state and managed execution. Always test end-to-end reliability, not per-step.

What is MCP in AI?

MCP, the Model Context Protocol, is an open standard (introduced by Anthropic) for connecting AI models to external tools and data sources through a consistent interface. Concretely: instead of writing a bespoke function-calling wrapper every time you connect Gemini to, say, your Postgres database and your Slack workspace, you expose each as an MCP server once, and any MCP-aware model can call them. It complements Google's Interactions API: where the Interactions API handles state and execution for Gemini specifically, MCP standardizes how tools are exposed across vendors — so the same database server works whether you're driving it from Gemini, Claude, or GPT. As agent ecosystems mature, expect convergence pressure between vendor-specific APIs and open protocols like MCP. See our workflow automation guide for how these layers fit together.

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 the Postgres-checkpointer-plus-sandbox research agent and the overnight loop that turned a $4 task into a $90 one referenced in this piece — 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.