Google's Gemini API Now Runs Persistent Background Agents — Every SaaS Platform Is Becoming an AI Agent Host

On July 7, Google shipped something that sounded like a developer tooling footnote: background execution for Managed Agents in the Gemini API, plus remote MCP server support and persistent agent environments that keep running when users disconnect. The API returns an interaction ID. You close your laptop. The agent keeps working.

It's not a footnote. It's the final confirmation of a pattern that has been building all year. Every major SaaS platform is turning itself into an AI agent host, and they're all doing it in their own way, on their own terms, with their own permission models. Nobody is coordinating with anyone else.

The thesis that "every SaaS platform becomes an agent platform" has been floating around since late 2025. What makes mid-2026 different is that it stopped being a prediction and started being the thing on your credit card bill. **Notion** shipped Workers in May. **Asana** bought StackAI and launched AI Teammates in June. **Zoom** dropped Agent Architect the same month. **Vercel** open-sourced Eve. And now Google has made Gemini agents persistent, sandboxed, and background-capable at the API level.

If you're building software right now, your stack is almost guaranteed to include at least three of these platforms. Congratulations: you now have at least three different agent runtimes, three different permission models, and zero way to govern them as a single system.

What exactly did Google ship?

The headline feature is background execution. You call the Interactions API with `background: true`, the API hands you back an ID immediately, and the agent runs server-side in a Google-hosted Linux sandbox until it's done. You poll for results. If the connection drops, no problem. The agent has its own persistent environment — a sandbox that survives across interactions, keeps installed packages and cloned repos, and only gets cleaned up after seven days of inactivity.

Behind that sits the Antigravity agent harness, powered by Gemini 3.5 Flash. It can execute code, browse the web, manage files, and now connect to your own remote MCP servers. The sandbox runs Ubuntu with Python 3.12 and Node.js 22. Compute isn't even billed during the preview period. You pay for tokens only.

Sascha Heyer, a Google Cloud Developer Advocate, put it bluntly in his walkthrough: "You send it a task, it hands you an id right away, and it runs server side in a sandbox while you go do something else." The demo repo ships three patterns: fire-and-forget, reconnect-by-ID, and attach a remote MCP tool. Each is maybe 30 lines of Python.

The developer experience is properly impressive. One API call. No container to provision. The agent just runs. But that's exactly what makes the governance questions harder, not easier.

Has every SaaS platform decided to build the same thing differently?

Walk through the past three months:

**Notion** (May 13) launched the Notion Developer Platform. Workers — Node/TypeScript programs that run on Notion's infrastructure — can sync data on schedules, act as tools for Custom Agents, and receive webhooks. They also shipped the External Agents API, letting you bring Claude, Codex, Decagon, or your own agents directly into Notion. Then the Agent SDK, so Notion agents can surface inside other apps. Notion's pitch: "Notion is your orchestration layer."

**Asana** (May 28) acquired StackAI and then (June 4) unveiled the "operating system for human-agent teams." AI Teammates now have a chat-based front door, a Skills library, and integrations with Gmail, Slack, HubSpot, Figma, and Canva. StackAI adds cross-system execution — agents that read and write across Salesforce, AWS, DocuSign, Oracle, and whatever else you've got. Asana's pitch: "Humans and agents working together at the right checkpoints."

**Zoom** (June 22) shipped Agent Architect, which turns a simple prompt into a production-ready voice or digital agent. It also shipped the Agent Performance Suite: pre-deployment simulation, real-time dashboards, a quality management framework that evaluates AI and human interactions under the same standard. And outcome-based pricing, tying your bill to resolved interactions. Zoom's pitch: "Move from conversation to completion."

**Vercel** (June 17) open-sourced Eve, a filesystem-first framework where an agent is literally a directory. `instructions.md` for the system prompt. `tools/` for TypeScript functions. `channels/` for Slack, Discord, Teams. Durable sessions that checkpoint every step and survive deploys. Human-in-the-loop approvals. Vercel's pitch: "Like Next.js for web apps, but for agents."

**Google** (July 7) gave us Managed Agents with background execution and persistent sandboxes. Google's pitch: "One API call. We handle the rest."

Five platforms. Five agent runtimes. Five permission models. Five different answers to the question "who authorised this agent to do that?"

What happens when nobody owns the governance layer?

Here's a scenario that isn't hypothetical. A customer requests a refund through your Zoom Virtual Agent. Zoom's agent needs to check the order in your database, which lives behind a Notion Worker that syncs from Salesforce. The Notion Custom Agent that handles refund logic then needs to create a task in Asana for the finance team to review. Along the way, Asana's AI Teammate spots a pattern and escalates to a manager.

That's four platforms, four agent runtimes, and at least three different OAuth chains. Who has the audit trail? If the refund goes wrong, which console do you open first? If sensitive customer data leaks through one of the agent hops, which platform's DLP policy caught it — if any?

This is not an edge case. TrueFoundry published an analysis on July 7 that nails the structural problem: "A DLP rule in one ecosystem does not apply to an agent in another calling the same sensitive data. A rate limit in one tool does not constrain a job in the next. Siloed policy is no policy at all."

They identified four dimensions where the governance gap bites: discovery (you can't govern agents you don't know exist), policy (rules stop at the platform boundary), identity (each platform issues its own agent identity), and lifecycle (no central kill switch when an agent goes wrong).

And there's the credential tax. Every agent on every platform wants its own OAuth token. Multiply by your employee count, then by your tool count. Now ask yourself: when someone leaves the company, how many agent credentials do you actually revoke?

The numbers back up the anxiety. Fifty-nine per cent of organisations are running agentic AI. Only twenty per cent have governance in place. Only six per cent of companies fully trust agents to autonomously execute core business processes. That's not caution. That's a rational response to a system nobody designed.

So who wins the agent platform war?

The boring answer — and I think the right one — is that nobody wins by being the best agent host. The winners will be the platforms that solve governance across agent hosts.

This is why Databricks open-sourced **Omnigent** on June 13. It's a meta-harness that sits above agents (Claude Code, Codex, Pi, custom) and provides composition, contextual security policies, cost controls, and live collaboration. **Gravitee** is making the same bet with its Agent Management Platform: one catalog, one policy engine, one enforcement layer for agents, APIs, and events. **TrueFoundry**'s Agent Gateway is pitching itself as "a service mesh built specifically for agentic systems."

Each of these is essentially saying: the agent runtime is commodity. The governance layer is the valuable part.

Google, Notion, Asana, Zoom, and Vercel are all building excellent agent hosts. But they're building agent hosts for *their* platform. Notion's governance tools stop at the Notion boundary. Asana's AI Teammates are governed within Asana. Zoom's performance suite measures Zoom agents.

Nobody is building the thing that sits above all of them and says: these are the rules, for all agents, everywhere.

The takeaway

If you're building or buying agentic software this year, ask one question before you ask anything about model quality or response latency: where does the governance live?

If the answer is "inside the platform," that's fine for single-platform automation. But if you're running agents across Notion, Asana, Zoom, and Google — and you probably will be — you need a governance surface that doesn't stop at anyone's API boundary.

The platforms that survive the next three years won't be the ones with the smartest agents. They'll be the ones that made agents governable. And right now, nobody in the big SaaS cohort has really tried.