Gemini Spark: Google's 24/7 AI Agent — I/O 2026 Developer Guide

At 10am PT today, Sundar Pichai unveiled the product every major AI lab has been racing to ship: a persistent, 24/7 personal AI agent that handles long-horizon tasks in the background, integrates with Gmail and Google Docs at a depth no API call can replicate, and connects to third-party services via MCP. Google calls it Gemini Spark — and the technical details buried in today’s I/O keynote are more significant for developers building agentic systems than the last three Gemini model releases combined.

Spark is not a new model. It is an agent: a persistent runtime that runs on dedicated Google Cloud virtual machines, stays online continuously, and takes autonomous action across your digital workspace. Google built it on Gemini 3.5 Flash — also announced today — and a previously internal platform called Google Antigravity, version 2.0 of which is available to external developers starting now.

The product rolls out to Google AI Ultra subscribers in the US starting next week. This guide covers what developers need from today’s announcement: the Spark architecture, the Antigravity 2.0 developer platform, what Gemini 3.5 Flash changes at the model layer, how MCP integration works, and where the opportunity is for developers building agent applications right now.

Spark vs. Gemini Assistant: What Actually Changed

“Agent” is overloaded. Every AI assistant claims to be agentic. Gemini Spark is worth examining precisely because its architecture differs meaningfully from what Google has shipped before.

The original Gemini assistant was stateless: send a query, receive a response, session ends. Extensions and function calling added the ability to invoke tools during a conversation, but each interaction remained bounded by a request lifecycle. Spark breaks that model. It runs persistently on dedicated Cloud VMs. It maintains goal state across hours and days. It can monitor your inbox on a schedule, cross-reference incoming emails against deadlines you described weeks ago, and draft responses before you’ve opened Gmail that morning. The session never ends.

Google describes this as “long horizon” execution — the ability to maintain context and goal state across time windows that no synchronous API call can span. A standard Gemini API call has a lifecycle measured in seconds. Spark’s lifecycle is measured in hours and days. That gap is the entire product.

At launch, Spark integrates with Gmail, Google Docs, Slides, and Sheets. Third-party integrations with Canva, OpenTable, and Instacart ship on day one. MCP-based expansion — covering GitHub, Notion, Slack, and any service with an MCP server — arrives over the summer. But for developers, the more significant announcement is what powers it underneath: Antigravity 2.0.

Google Antigravity 2.0: The Developer Platform Behind Spark

Google Antigravity is the AI-native development platform the company uses internally to build Spark and its other production agent systems. Version 2.0, released today, opens it to external developers as a standalone desktop application with a CLI and SDK.

Three layers define the architecture.

The agent harness wraps Gemini model calls with infrastructure for goal persistence, task decomposition, tool orchestration, safety constraints, and state recovery. This is the component Google describes as preventing agents from “going rogue” — a constraint system that bounds autonomous action to what you explicitly authorize. The harness is available via the Antigravity SDK, meaning you can use the same infrastructure that powers Spark in your own applications.

The orchestration layer is new in version 2.0. The desktop app lets you spawn multiple autonomous agents in parallel, assign them different goals, and have them coordinate via a shared state store. Each agent runs on its own goroutine inside the Antigravity runtime; message-passing between agents is handled by the platform rather than custom coordination code. The CLI exposes the same primitives for terminal-first developers.

The built-in MCP gateway handles server discovery, authentication, connection management, and tool routing for all connected MCP servers. You configure endpoints in a manifest file; Antigravity manages reconnection on failure, request batching, and error handling. Building a multi-tool agent that connects GitHub, Notion, and a custom internal API becomes a configuration task, not an infrastructure one.

# Antigravity 2.0 agent manifest (simplified)
name: "pr-review-agent"
model: gemini-3.5-flash
persistence: cloud     # runs on Google Cloud VMs 24/7

tools:
  mcp_servers:
    - endpoint: "https://github.mcp.io"
      auth: oauth
    - endpoint: "https://notion.mcp.io"
      auth: bearer_token
    - endpoint: "http://localhost:3001"   # custom internal server
      auth: none

goals:
  - name: "daily-pr-digest"
    trigger: cron("0 9 * * 1-5")          # weekdays 9am
    task: >
      Review all PRs opened since yesterday.
      Summarize findings, flag blocking issues,
      and post digest to #eng-reviews Slack channel.

safety:
  max_tool_calls_per_goal: 50
  require_user_confirm: ["git_push", "send_email", "payment_*"]
  allowed_data_sources: ["github.com", "notion.so", "localhost"]

The manifest-driven design is deliberate. Antigravity 2.0 targets the developer who wants production-capable autonomous agents without writing custom orchestration infrastructure. The safety constraints are first-class citizens — defined in the manifest, enforced at runtime. An agent that unexpectedly expands its tool usage hits the configured limit automatically rather than silently overrunning its scope. That behavior is not free in a hand-rolled agent loop; in Antigravity, it is the default.

The same logic that makes the MCP ecosystem compelling applies here: configure the connections, define the goals, let the harness handle coordination and constraint enforcement.