DEV Community: Uddhav Bhople

Gemini Spark Changed How I Think About Agents And I Haven't Even Used It Yet

Uddhav Bhople — Sat, 23 May 2026 17:44:54 +0000

I've been building with AI APIs for about a year now. FairLens AI, an election assistant, an Instagram Reels pipeline. All of them follow the same mental model: user sends input → model reasons → model responds → done. Clean, predictable, stateless.

Google I/O 2026 just broke that model for me and not with a new benchmark or a faster inference time. It broke it with architecture.

The Announcement That Actually Matters

Everyone's talking about Gemini 3.5 Flash (fair, it's fast and strong). People are excited about the intelligent eyewear hardware drop. Those are real. But the announcement that's been living rent-free in my head since May 19th is Gemini Spark.

Here's the one-line pitch: Spark is a 24/7 personal AI agent that runs on dedicated Google Cloud VMs continuously, in the background whether your laptop is open or not.

Simple sentence. Massive implication.

Why This Is Architecturally Different

Every "agentic" product I've built or used before Spark was secretly still stateless. You'd give it a task, it'd execute a sequence of tool calls, return a result. The session ended. The agent didn't persist it just called more functions before replying.

Spark breaks this pattern at the infrastructure level. It's not a longer context window. It's not function-calling wrapped in a loop. It's a runtime a persistent process running against a dedicated VM on Google Cloud. Sundar Pichai described it in the pre-briefing: "It runs on dedicated virtual machines on Google Cloud seamlessly you don't need to keep your laptop open to make sure it's running."

That's not a chatbot. That's a daemon.

The old model: you invoke the agent.
The Spark model: the agent is already running.

The Antigravity Connection (Developer Side)

What makes this exciting for builders isn't just the consumer product it's the platform beneath it.

Spark is built on Gemini 3.5 Flash + Google Antigravity 2.0, which is now externally available. Antigravity is Google's agent-first development platform, and at I/O they announced:

Managed Agents API a single API call spins up a fully provisioned agent with a remote sandbox. No infra setup. No keeping a server warm. You describe the agent, the harness handles execution.
Antigravity SDK programmatic control if you want to self-host and customize the agent behavior on your own infra.
Antigravity CLI spin up subagents to handle complex workflows with built-in credential masking and terminal sandboxing.

This is the part that made me close Twitter and open a notes doc. The Managed Agents API specifically targets the exact friction point that stopped me from building truly long-running agents: I don't want to manage the infra for a process that needs to stay alive for hours.

MCP Support: The Open Web Angle

Spark launches with MCP (Model Context Protocol) integration for third-party tools. But what was more interesting to me from the dev keynote was WebMCP a proposed open web standard that lets developers expose JavaScript functions and HTML forms as structured tools that browser-based AI agents can call with precision.

Think about what that means: you're not just giving agents an API endpoint. You're giving them the ability to reason about your app's UI surface and act on it reliably. The experimental origin trial starts in Chrome 149, and support for Gemini in Chrome is coming soon.

For anyone building apps with agentic workflows baked in, WebMCP is a standard worth watching early.

My Honest Take: What I'm Skeptical About

I want to flag a few things I'm not ready to be fully hyped about yet.

Availability is gated. Spark is rolling out to trusted testers first, then Google AI Ultra subscribers in the US. If you're outside the US or not on Ultra, you're waiting. For a dev community that's globally distributed, this matters.

Long-horizon trust is unsolved. Spark is designed to "check with you before taking major actions" which is the right call. But what counts as a major action is still fuzzy. Autonomous agents that touch email, calendar, and docs on your behalf introduce new error modes that we don't have good mental models for yet. Sending the wrong email is much worse than autocompleting the wrong word.

It's very early. Google said so explicitly. "Gemini Spark is very early in its product journey." This announcement is a direction statement more than a shipping product right now.

That said the direction is right. And the underlying platform (Antigravity, Managed Agents API) is real and available today.

What I'm Actually Going to Build

Here's where I land after sitting with this for a few days:

The Managed Agents API on Antigravity removes the biggest blocker I've had for building async, long-running workflows. I've been thinking about VolunteerNear a hyper-local volunteer/gig platform I'm PRDing right now. The matching logic between volunteers and opportunities doesn't need to be synchronous. A persistent background agent that monitors new postings, cross-references volunteer profiles, and nudges relevant people asynchronously? That's a fundamentally better UX than a feed the user has to manually refresh.

Before I/O, that meant managing a Celery queue, a Redis instance, and probably a background worker on Railway. With Managed Agents, that becomes one API call and a well-structured system prompt.

That's a real unlock.

Final Thought

Google I/O 2026 wasn't about a new model. The model (3.5 Flash) is good, but incremental. The real announcement was a shift in the execution model for AI.

From: agents as subroutines you call.
To: agents as processes that run continuously.

If that transition happens and Antigravity + Spark suggest Google is serious about making it happen it changes how we design apps, how we think about user interaction, and what "background task" means for AI-native products.

I'm skeptical about timelines. I'm excited about the direction.

That's probably the right combination of feelings for May 2026.

I built a multi-agent IPL captain cool AI on Gemini

Uddhav Bhople — Sun, 17 May 2026 12:51:16 +0000

Cricket is a captain's game. And for 3 hours at a Google AI hackathon, I became one — by building Captain Cool, a multi-agent IPL strategist powered entirely by Google Gemini. Not a chatbot. Not a form with a Gemini call. A real debate between AI agents — the way a captain's brain actually works.

The problem

Every IPL captain faces split-second decisions — who bowls the death over, when to bring in the Impact Player, how to set the field against a left-hander in dew. These calls win or lose matches.

I wanted to build an AI that doesn't just answer "who should bowl?" but actually debates it, shows its reasoning, and tells you what happens if you make the wrong call.

Architecture

Instead of one Gemini call wearing 4 hats, I built 4 named agents with distinct roles that talk to each other:

User Input (Cricbuzz URL or manual match state)
                ↓
         Orchestrator
┌─────────────────────────────────────┐
│ Agent 1: Stats Analyst              │ ← Google Search tool call
│ Agent 2: Strategist (persona-based) │ ← Proposes the call
│ Agent 3: Devil's Advocate           │ ← Challenges it hard
│ Agent 4: Commentator                │ ← Final output + counterfactual
└─────────────────────────────────────┘
                ↓
    Decision + Debate UI + Voice Output

The 4 agents

Agent 1 — Stats Analyst

Uses Gemini's built-in Google Search tool to fetch live player form and head-to-head stats. Not hardcoded JSON — real tool use.

System prompt:

You are an IPL stats analyst. Analyze pitch conditions, dew factor,
bowler economy rates, and batter weaknesses. Use Google Search to
fetch current player form. Output structured JSON with: key_stats,
batter_weakness, bowler_recommendation, win_probability (%).

Agent 2 — Strategist (Persona-driven)

The user picks a captain persona — and the entire system prompt personality changes:

🧊 Dhoni mode:

You are MS Dhoni. Ice in your veins. You back your bowlers,
never panic, always think 2 overs ahead. Make ONE decisive call. No hedging.

💥 Rohit mode:

You are Rohit Sharma. Bold and aggressive. Back your instincts
and your big hitters. Make the attacking call others won't.

🔥 Hardik mode:

You are Hardik Pandya. Unconventional and fearless.
Make the call that surprises everyone but works.

Agent 3 — Devil's Advocate

You are a sharp rival captain. Challenge the Strategist's decision hard.
Find the flaw. Propose a specific alternative.
Format: CHALLENGE: [what's wrong] | ALTERNATIVE: [what you'd do instead]

Agent 4 — Commentator

You are Harsha Bhogle. Explain the final call in vivid cricket language
a passionate fan would love. Include: why this decision, why NOT the
alternative, a counterfactual ("if they'd bowled X, win prob drops ~Y%"),
and a confidence score out of 10.

Orchestrator flow

Extract match state from Cricbuzz URL using Gemini's URL context tool
Stats Analyst runs Google Search → structured JSON with win probability
Strategist (selected persona) proposes tactical decision
Devil's Advocate challenges with a specific alternative
Strategist defends or revises → final call
Commentator delivers cricket-language output + counterfactual + confidence score + voice via Web Speech API

One full match scenario

Match state:

MI vs CSK · 2nd innings · Over 16 · CSK need 34 off 24 · 4 wickets down
Rohit Sharma on strike (67*) · Jadeja non-striker (12*)
Bumrah has 2 overs left · Chahal has 1 · Flat pitch · Heavy dew · Wankhede

Stats Analyst: Win prob MI 58% / CSK 42%. Dew negating seam movement. Jadeja vulnerable to pace outside off.

Strategist (Dhoni mode): Bowl Bumrah now — back him to nail yorkers despite the dew.

Devil's Advocate: Dew renders Bumrah's seam movement useless tonight. Save him for over 19. Bowl Chahal now while Jadeja is on strike — he's the weak link against leg spin.

Strategist (final call): Point conceded. Chahal to bowl over 17. Bumrah held for over 19.

Commentator: "In dew-heavy Wankhede, Bumrah's famous seam is rendered ineffective. Rohit holds him back for the 19th — calm, calculated captaincy. If they'd bowled Bumrah here, win probability drops to 51%. Confidence: 8/10." 🎙️

What made us stand out

At the hackathon, 100+ developers were building the same thing — a form that calls Gemini and returns formatted text. Here's what we did differently:

Real agent debate visible in the UI — shown as chat bubbles, not hidden or summarized
Captain persona selector — same agents, completely different personality per captain
Live Cricbuzz scraping — paste a URL, Gemini extracts the match state automatically
Counterfactual — we don't just tell you what to do, we tell you what happens if you don't
Voice output — the commentator speaks the final call aloud via Web Speech API

Tech stack

Layer	Technology
Frontend	TypeScript + Vite + CSS
AI model	Google Gemini 2.5 Flash
SDK	@google/genai
Tool use	Gemini built-in Google Search
Voice output	Web Speech API
Build environment	Google AI Studio

googleai #gemini #cricket #apl #hackathon #multiagent #typescript #gdgcloudpune #gdgcloudpune2026