generateContent Time to retire: Google releases Interactions API

Google has made its move.

Recently, Google officially released the Interactions API—a brand-new interface designed specifically for building agentic applications. This is not yet another minor iteration, but an architectural-level addition to the existing generateContent endpoint—or even, one could say, a conceptual replacement.

For developers who have been using the Gemini API to build agents, the message between the lines is clear: Google is acknowledging that the old API can no longer meet the demands of the agent era.

The Bottleneck of generateContent—Long Overdue for Discussion

Let’s review the background.

generateContent is the core endpoint of the Gemini API, a design that’s rooted in a classic paradigm: you send a prompt, the model returns a completion—stateless, one question and one answer. Perfectly fine—and even elegant—for the era of pure text generation.

But starting in the second half of 2025, things changed. Model capabilities expanded rapidly from “generating text” to “thinking + using tools + multi-step execution.” Now you might want the model to first search the web, then query a database, generate a report based on the results, and finally push that report into a system—a typical agent workflow involving multi-turn interactions, intermediate states, tool calls, and asynchronous execution.

Can you force-fit all that into generateContent? Sure—but at what cost?

In Google’s own words: “It makes the API too fragile.” Translated into developer-speak: you have to manually manage conversational state on the client side, orchestrate tool call chains, handle serialization/deserialization for every intermediate state, and end up with brittle, unmaintainable code.

This isn’t unique to Gemini. OpenAI’s Chat Completions API faces similar pain when dealing with complex function-calling chains—hence the eventual introduction of the Assistants API and the Responses API. Anthropic’s Claude tries to solve the issue with a tool_use message type, but multi-step orchestration still requires developers to build their own scaffolding.

In other words, the whole industry faces the same problem: APIs designed for “conversation” aren’t enough for “doing things.”

Google’s solution? A brand-new endpoint.

What Exactly Has Changed with the Interactions API

From the public information available, the core design of the Interactions API can be broken down into several key points:

1. Unified RESTful Endpoint

No more distinction between “talking to a model” and “asking an agent to act.” One endpoint handles both—you specify via parameters whether you’re interacting with a raw model or a preconfigured agent. This means developers don’t have to jump between different API paths.

The design philosophy here is similar to OpenAI’s Responses API—both seek to unify complexity under one entry point. But Google goes a step further: it promotes agents to first-class citizens at the API level, rather than hiding them behind abstractions like Assistants.

2. Server-Side State (Optional)

This is the biggest change.

generateContent is stateless—you must include the full conversation history in every request. The longer the chat, the more tokens burned and the higher the latency. The Interactions API, however, supports server-side state management—you can choose to let Google maintain the state or stay stateless if you prefer.

For agent scenarios, this is almost a necessity. Imagine a ten-step workflow, where each step involves tool calls and waiting for results. If you have to resend the entire preceding context every time, it’s inefficient and risks overflowing the context window.

Server-side state makes this simple: you initiate an interaction session, subsequent steps automatically inherit the context, and you only worry about inputs and outputs for the current step.

3. Explainable and Composable Data Model

Google uses an interesting term here—“explainable.” That means the API response is no longer an opaque text blob but structured, machine-readable, and composable data.

For example: the model calls a tool during reasoning, the tool returns results, and the model continues reasoning based on them. In the Interactions API, every step of that process is surfaced in a structured way. You can see precisely which tool was called, what decision was made, and what results were obtained.

This is a huge improvement for debugging and observability. Anyone who’s dealt with OpenAI’s function calling knows how painful it is to diagnose issues in a tool call chain.

4. Background Execution

This feature addresses long-running tasks directly.

Not every agent task finishes in seconds. Some may take minutes or longer—like deep research, complex data analysis, or multi-system coordination. The Interactions API allows such tasks to be submitted for background execution, so the client doesn’t need to keep a long connection open.

This aligns perfectly with the upgraded Gemini Deep Research capability. Deep Research is a prime example of a long-running task—planning, searching, reading, synthesizing, and reporting. Such workflows are painful to handle via synchronous APIs.

5. Remote MCP Tool Support

This one deserves its own spotlight.

MCP (Model Context Protocol) was introduced by Anthropic in late 2024 as an open standard defining how models discover and call external tools. After more than a year of evolution, MCP has become the de facto standard for tool integrations across major model providers.

By supporting remote MCP tools natively, the Interactions API lets you plug MCP-compliant tool services directly into Gemini agents without an adapter layer. This sharply lowers the integration cost for the tool ecosystem.

In combination with Google’s A2A (Agent2Agent) protocol introduced last year, Google’s agent infrastructure strategy is becoming clear: A2A handles inter-agent communication, MCP handles agent-to-tool interaction, and the Interactions API becomes the unified interface for developers.

How Does Google’s Move Compare to Competitors?

Frankly, the Interactions API isn’t a “zero-to-one” innovation. It’s more of a fast follow and system-level consolidation, informed by where the industry is headed.

OpenAI introduced server-side state and tool orchestration with the Assistants API back in late 2023, and followed up in 2025 with the lighter-weight Responses API. Anthropic doesn’t have a separate Agent API, but its combination of extended thinking, tool_use, and MCP achieves similar outcomes within Claude.

Google’s advantage lies in its systemic late-mover strategy. Instead of patching the old API, it’s designing a new endpoint from the ground up—data model to execution mode—for agent workflows. That kind of “tear down and rebuild” courage is rare in big companies.

Another key strength: ecosystem integration. The Interactions API isn’t standalone—it’s part of a broader agent development stack with Vertex AI Agent Engine, the A2A protocol, and Google Workspace integrations (like the recently launched Agent2UI). For apps deeply integrated in the Google Cloud ecosystem, this is an appealing package.

Still, there are risks. Google has a reputation for fast iterations and abrupt deprecations. generateContent still works today—but how long will it live now that Interactions API is here? If you just built a custom orchestration layer around it, who absorbs the migration cost?

Google owes developers a clear signal: will the two APIs coexist, or will Interactions ultimately replace generateContent entirely?

What This Means for Developers

If you’re building agent applications, the launch of the Interactions API conveys several clear signals:

First, API design is shifting from the “conversation” paradigm to the “task” paradigm. Whether it’s Google’s Interactions API, OpenAI’s Responses API, or Anthropic’s tool calling setup, all major providers are reorienting their APIs around agent workflows. If you’re still manually orchestrating multi-step tasks via plain chat completions, it’s time to upgrade.

Second, MCP is becoming the universal language for tool calling. With Google’s native support and backing from OpenAI and Anthropic, MCP’s position as the standard is solid. If you’re building tools for AI to call, implementing an MCP interface is the safe bet.

Third, server-side state management will be standard. Stateless APIs still work for simple use cases, but for complex workflows, server-managed state is virtually required. That means you’ll need to rethink architecture—where state is stored, how it's managed, how to recover it.

Practical Usage: Accessing Gemini via OpenAI-Compatible Format

For developers already using OpenAI-compatible SDKs, good news: Gemini models support the OpenAI API format, including tool calling. Platforms like OpenAI Hub let you call GPT, Claude, Gemini, DeepSeek, etc., with a single key—just change a parameter to switch models.

Example: calling a Gemini model and using tool calling via the OpenAI-compatible interface:

from openai import OpenAI

client = OpenAI(
    api_key="your-openai-hub-key",
    base_url="https://api.openai-hub.com/v1"
)

# Define tools
tools = [
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "Search the product database and return matching product info",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Search keyword"
                    },
                    "category": {
                        "type": "string",
                        "description": "Product category",
                        "enum": ["electronics", "clothing", "books"]
                    }
                },
                "required": ["query"]
            }
        }
    }
]

# Step 1: Send request; model decides whether to call a tool
response = client.chat.completions.create(
    model="gemini-2.5-pro",  # Gemini via OpenAI Hub
    messages=[
        {"role": "system", "content": "You are a product search assistant helping users find product info."},
        {"role": "user", "content": "Find me the latest noise-canceling headphones."}
    ],
    tools=tools,
    tool_choice="auto"
)

# Step 2: Handle the tool call
message = response.choices[0].message
if message.tool_calls:
    tool_call = message.tool_calls[0]
    print(f"Model requested tool: {tool_call.function.name}")
    print(f"Arguments: {tool_call.function.arguments}")

    # Simulate tool result
    tool_result = '{"products": [{"name": "Sony WH-1000XM6", "price": 2499}]}'

    # Step 3: Return result to model to generate final response
    final_response = client.chat.completions.create(
        model="gemini-2.5-pro",
        messages=[
            {"role": "system", "content": "You are a product search assistant."},
            {"role": "user", "content": "Find me the latest noise-canceling headphones."},
            message,  # assistant message containing tool_calls
            {
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": tool_result
            }
        ]
    )
    print(final_response.choices[0].message.content)

This code still demonstrates the chat.completions-style tool calling paradigm—the very one the Interactions API aims to improve. Once Interactions API support expands and compatible layers catch up, the experience for multi-step reasoning and state management will improve drastically.

And if you want to benchmark different models (e.g., Gemini 2.5 Pro vs Claude Sonnet 4 vs GPT-4o) for tool-calling performance, aggregation platforms make switching trivial—no separate API keys or SDKs needed.

The Bigger Picture: The Agent Infrastructure Arms Race

Zooming out, the Interactions API launch is just one of several major moves in the AI Agent space in recent weeks.

In the same window: Anthropic’s Claude Computer Use officially arrived on Mac, allowing direct desktop control; JetBrains released IntelliJ IDEA 2026.1 with built-in multi-agent support via the ACP protocol; Google’s internal Agent Smith tool became so popular it brought servers down—Larry Page himself reportedly helped fix the code.

All these point to one trend: By 2026, agents are moving from proof-of-concept to production—and the infrastructure race is just starting.

Google’s strategy is clear: Interactions API as the developer entry point, A2A as the inter-agent protocol, Vertex AI Agent Engine as the managed runtime, and MCP compatibility for tool integration. It’s a full, top-down agent platform stack.

OpenAI follows a different path: Responses API + Agents SDK + built-in tools (web search, code interpreter, file search), emphasizing an out-of-the-box experience. Anthropic is more restrained—focusing on model capabilities (extended thinking, computer use) and leaving orchestration to the ecosystem.

Three approaches, each with strengths. For developers, the most pragmatic strategy might be: keep core business logic model-agnostic, use compatibility layers and open standards (MCP, A2A) to abstract dependencies, and avoid lock-in.

After all, this arms race is far from over. Today’s best practice might need rethinking half a year from now. Flexibility will be more valuable than allegiance.

---

References

• Google’s Agent Push: Enhanced Gemini Deep Research and Dedicated API Now Available - Sina Tech — Details of the Interactions API release and comparison with generateContent
• AI Intelligence: Claude Can Control Macs, Google’s Internal Agent Crashes Servers - Everyone Is a Product Manager — Roundup of recent major AI Agent developments
• Agent2Agent Protocol - Baidu Baike — Technical details and evolution of the A2A protocol
• Build Google Chat Apps with Agent2UI Proxy - Google Developers — Real-world example of Google Agents integrating with Workspace