93 Agents. One OS. Twelve Hours. Under $1,000.
I need to tell you something before we get into the announcements.
For months, I've been building an app — a kind of AI operating system where specialized agents each own a domain. A coding agent. A design agent. A research agent. Each one has real programming functions as its tools. They don't just answer questions — they do things. And the core idea? Put them in a shared space where they collaborate, challenge each other, and make better decisions together than any single agent could alone.
Then Google I/O 2026 happened.
I sat through the keynote, the developer keynote, the Firebase session, the Flutter session, the AI deep-dive — and kept seeing my own architecture reflected back at me. Multi-agent parallelism. Specialized sub-agents spawning on demand. Agents triggering backend functions. Agents building UI in real time.
It wasn't a "they stole my idea" moment. It was a "the entire industry is converging on this pattern" moment. And that's way more interesting. 😅
Let me walk you through what Google actually shipped, why it matters, and the one thing I think they're still missing.
Google Didn't Ship Features. They Shipped an Architecture.
Here's what most coverage will miss: the individual announcements aren't the story. The connection between them is.
Google rebuilt every layer of their platform around one assumption — agents are the new primary users of software infrastructure. Not humans clicking buttons. Agents making API calls, triggering functions, rendering UI, and executing transactions.
Once you see it, you can't unsee it.
The Foundation: Models That Execute, Not Just Respond
Three model drops. One common thread: they're built for doing.
Gemini Omni — a multimodal family that takes any input and produces any output. It understands physics. It edits video through conversation. It reasons about the real world spatially. The first variant, Omni Flash, shipped the same day.
Gemini 3.5 Flash — frontier-class, 4x faster than comparable models, aggressively cost-optimized. Why does speed matter this much? Because when an agent makes 200 API calls to complete one task, latency compounds. Fast and cheap isn't a nice-to-have. It's the difference between agents being viable and agents being a toy.
Gemma 4 — open-source under Apache 2, 100 million downloads in month one. Runs offline on mobile. Optimized for reasoning and agentic workflows. This is the model that keeps working when your connection drops.
And underneath all of it: 8th-gen TPUs split into dedicated training (TPU 8) and inference (TPU 8i) chips, deployed across a million+ units globally. They're not just building models for agents. They're building silicon for agents.
The Dev Layer: Anti-Gravity 2.0 Is Not an IDE
This is where I started taking notes furiously.
Google Anti-Gravity 2.0 isn't a code editor with AI bolted on. It's a standalone desktop application — a mission-control hub where multiple agents work on your project simultaneously.
One agent writes frontend code. Another generates design assets. A third reviews architecture decisions. They don't step on each other because the system manages git branching automatically.
The headline demo: 93 autonomous sub-agents built a functioning operating system in 12 hours for under $1,000 in API credits.
Let that sink in. Not $1,000 per agent. $1,000 total. For an OS. 💀
Now — is that OS production-ready? Almost certainly not. 🙃 But the economics are the point. The cost floor for complex software just dropped through the floor.
What makes Anti-Gravity genuinely different:
- Dynamic sub-agents — your primary agent spawns temporary specialists (QA, data science, security audit) when it needs them, then dismisses them
- Cron scheduling — agents on autopilot. Scan PRs every morning. Monitor cloud health hourly. Run regression tests at midnight.
-
Markdown orchestration — define multi-agent workflows in
.mdfiles. No pipeline code. No YAML hell. - Managed agents via API — one API call spins up an isolated agent with its own secure Linux sandbox
- Enterprise mapping — connects directly to corporate Google Cloud projects under existing compliance
The Gemini CLI got folded into the Anti-Gravity CLI, so terminal-native developers get the same backend without leaving their workflow.
This is the pattern I've been building. Specialized agents, real tools, parallel execution. Seeing it at Google scale tells me the architecture works. 😳👍
The Backend: Firebase Now Serves Agents as First-Class Citizens
This one flew under the radar, but it might be the most important infrastructure shift for anyone building agent-powered apps.
Firebase is no longer just "a backend for mobile apps." It's now explicitly a backend for autonomous agents.
Agent-Triggered Cloud Functions — functions fire when an agent does something, not just when a human taps a button. Your agent completes a research task? That triggers a function to store results, notify the user, and queue the next step.
Delegated Authorization — Firebase Auth now handles agent identity. An AI acts on your behalf with explicit, scoped permissions. This is the plumbing that makes "hey Gemini, book me a flight" actually work without giving the agent your entire Google account.
Hybrid Inference — models run locally on-device (expanding to Gemma 4), falling back to cloud only when needed. This isn't just about cost. It's privacy architecture. Your personal data stays on your device unless it absolutely has to leave.
Security That Actually Thinks About Agents
Google shipped three security features that tell me they've thought hard about the attack surface:
Template-Only Mode — Firebase AI Logic only executes prompt templates stored on your server. If a malicious client tries to inject custom prompts? Ignored. Completely.
Authentication-Mode — every Gemini API call requires a valid Firebase token. No token, no execution. Period.
App Check Replay Protection — one-time tokens prevent attackers from replaying valid requests to drain your AI quota.
These aren't afterthoughts bolted on after a security review. They shipped alongside the agent features. That's a good sign.
The Frontend: UI That Builds Itself
Two threads here, both wild.
Flutter Agents
Agentic Hot Reload — AI coding agents can discover your running Flutter app, connect to it, and hot-reload changes as they write code. You watch your app transform in real time while the agent works.
GenUI + A2UI Protocol — instead of returning text, AI composes actual interactive Flutter widgets on the fly. They're exploring interpreted bytecode delivery — your app's UI evolves without an app store update.
Oh, and Flutter now powers the 2026 Toyota RAV4 infotainment system. Not a demo. Not a concept car. A mass-market production vehicle. That's a credibility milestone.
Canonical (the Ubuntu company) officially took over as lead maintainer for Flutter Desktop across Linux, Windows, and macOS. The "will Flutter desktop survive?" question is answered.
The Web Gets Agent-Aware
WebMCP — a proposed standard where websites declare tools and capabilities directly to browser-based agents. Think of it like robots.txt for the agent era. Instead of telling crawlers what to avoid, you tell agents what they can do.
Origin trials in Chrome 149. If this gets adoption, it rewrites how agents interact with the entire web.
Chrome DevTools for Agents — a new "Agentic Browsing" category in Lighthouse. Agents self-audit accessibility, validate discovery maps, catch errors, and deploy their own fixes. The browser becomes the agent's workspace.
The Consumer Layer: Agents in the Wild
Gemini Spark — a 24/7 personal agent running on dedicated cloud VMs. It works while you sleep. Close your laptop, the agent keeps going.
Agentic Commerce — three building blocks for agents that buy things:
- Universal Commerce Protocol (UCP) — an open standard backed by Amazon, Meta, and Microsoft for agent-to-merchant communication
- Agent Payments Protocol (AP2) — secure payment tracking with strict guardrails
- Universal Cart — cross-merchant intelligence that catches compatibility errors (mismatched PC parts) and tracks price drops
Amazon and Microsoft signing onto UCP is the real signal. This isn't Google going solo. It's an industry bet.
Audio Glasses — launching Fall 2026 with Samsung, Qualcomm, Warby Parker, and Gentle Monster. Gemini whispers in your ear. Orders your coffee through DoorDash. No screen. No phone. Just voice. 👀✨
What I Think Is Still Missing (And Why It Matters)
Here's my genuine take — the part that goes beyond reporting.
Google showed agents working in parallel. That's powerful. But parallel isn't the same as collaborative.
What I mean: Anti-Gravity has one agent on frontend, another on design, another on architecture. They work simultaneously. Great. But are they talking to each other? Are they debating tradeoffs? Is the architecture agent pushing back when the frontend agent makes a decision that creates tech debt?
The pattern I keep coming back to — and the one I've been building toward — is agent deliberation. A group conversation where specialized agents don't just execute in their lane, but actively challenge each other.
Picture it: a coding agent proposes an implementation. A QA agent immediately flags three edge cases. A design agent says the UX flow doesn't work. An architecture agent weighs in on system-wide implications. They go back and forth. They converge on a decision that's better than any single agent would produce alone.
This isn't parallel execution. It's peer review at machine speed.
Google has all the pieces — the models are fast enough, the sandboxing works, the infrastructure scales. But the "agents arguing productively in a room" pattern? I haven't seen anyone ship that at scale yet.
I think that's the next frontier. And I think whoever cracks it — whether it's Google, an open-source project, or an indie dev working late at night 😢 — unlocks a step-change in output quality that parallel execution alone can't match.
The Honest Concerns
I'm excited. I'm not blind.
Lock-in is the business model. Anti-Gravity + Firebase + Gemini API + Cloud Run + TPUs. Once you build on this stack, leaving is expensive. Google knows exactly what they're doing. 🙂↔️
The 93-agent OS is a headline, not a benchmark. We don't know what "functioning" means. Can it handle edge cases? Run real applications? The economics are compelling, but the quality bar is undefined.
Agent commerce trust doesn't exist yet. People barely trust chatbots to summarize a Wikipedia article correctly. Handing them a credit card is a different conversation. 😬 UCP and AP2 are technically sound. Consumer trust is years behind the technology.
Security is necessary but not sufficient. Template-Only Mode is clever. But the attack surface of agents with autonomous backend access is enormous. What about prompt injection through data they process? What about agents that need dynamic prompting by design? The tension between capability and safety isn't resolved — it's just acknowledged.
So What Does This All Mean?
Google I/O 2026 told one story across six hours of content: agents are becoming the primary consumers of software infrastructure.
Every layer got rebuilt:
- Models optimized for speed and tool use
- Developer tools that treat agents as builders
- Backends that authenticate and authorize agent actions
- Frontends that declare capabilities to agents
- Consumer products where agents act autonomously
- Hardware that puts agents in your ear
As someone building multi-agent architecture independently, this week felt like validation. The patterns work. The economics are arriving. The infrastructure exists.
But the most interesting problem is still open: how do you get agents to think together, not just work side by side?
That's what I'm chasing. And after watching Google put the foundation in place, I'm more convinced than ever that collaborative agent reasoning — not just parallel execution — is where the real unlock lives.
The agentic era isn't coming. It showed up on May 19, 2026, wearing a Google badge. 🎫
Now the question is: what do we build on top of it?