Google Antigravity and the direction of agent-first IDEs (Quokka Labs style)

Quokka researcher's urgent report: Google did it again

Hello, I am Quokka Labs researcher Dante. I recently tried Google's new IDE called Antigravity and was genuinely surprised. It goes beyond code autocomplete and evolves IDEs into agents that perform the work itself. Antigravity puts this shift at the center and redesigns the IDE for the agent-first era.

In this post, I will summarize what Antigravity is, its structure and philosophy, and how it differs from existing AI IDEs, in a friendly Quokka Labs tone.

TL;DR

Antigravity presents a dual product structure: IDE + Agent Manager.
Key keywords are Trust, Autonomy, Feedback, Self-improvement.
It emphasizes artifact-first asynchronous communication where agents explain and verify their work.
It includes a dedicated Browser Subagent, Knowledge Items for memory, and an MCP store for tool connections.
Pricing ranges from a free individual plan to expanded plans based on Google One/Workspace/Cloud.

Antigravity, what is different? (agent-first)

Traditional AI IDEs like GitHub Copilot or JetBrains AI Assistant mostly act as assistive tools for developers. They suggest code, explain errors, or help with small refactors.

Antigravity is different. The agent is the center, not the developer. When you ask for a feature, the agent makes a plan, writes code, runs tests, and even checks the UI in the browser autonomously.

Category	Traditional AI IDEs (Copilot, JetBrains AI)	Google Antigravity (agent-first IDE)
Role	Developer assistant (Copilot)	Autonomous teammate (Agent)
Workflow	Code suggestions, error explanations, small refactors	Full task execution (plan, coding, testing, verification)
Philosophy	Human-first	Agent-first

Quokka researcher's highlight: Browser subagent

The most impressive part for me was the browser subagent. After writing code, the agent opens a browser, verifies the UI, and even captures screenshots. It feels like a teammate saying, "Please check the feature I built."

This shows Antigravity is not just a code generator, but an IDE that finishes real work.

Core components of Antigravity

Antigravity is not a single program, but an agent ecosystem that connects multiple agents and tools.

Agents:
- Browser subagent: Controls the web browser and runs UI/UX tests and verification.
- Knowledge agent: Learns project docs, codebases, and external docs to build the agent's knowledge base.
- Artifact agent: Manages code, tests, and docs as artifacts and handles versioning.
Secure Mode:
- Provides a sandboxed environment to prevent agents from accessing sensitive files or running malicious code. In a world with RCE risks, this brings peace of mind.
MCP (Model Context Protocol):
- The standard protocol that connects Antigravity agents to external tools. It is notable that MCP, which Quokka Labs emphasizes, is at the core of Google's IDE too.

Quokka Labs insight: questions raised by agent-first IDEs

Antigravity asks an important question.

"What should developers do now?"

If agents handle much of coding, testing, and debugging, developers can focus more on what to build: problem definition, system design, and architecture decisions. Higher-level thinking and creativity matter even more.

What is Antigravity

The official site describes Antigravity as:

Agent-first development platform
A multi-surface agent that spans editor, terminal, and browser
A workflow that makes artifacts and verification results visible to build trust

In short, it centers the experience on "agents plan, execute, and verify on their own." If traditional AI IDEs are "chatbots inside the editor," Antigravity is closer to "agents lead while users manage and give feedback."

Core philosophy: Trust, Autonomy, Feedback, Self-improvement

The official blog summarizes Antigravity's direction into four principles.

Trust
- Showing only tool call logs does not build trust.
- Antigravity emphasizes summaries, verification results, and artifacts per task.
Autonomy
- In-editor agents matter, but Antigravity adds a Manager view to run multiple agents across workspaces.
Feedback
- To turn an 80% automated result into 100%, the feedback loop is critical.
- You can comment on text/image artifacts to issue asynchronous corrections.
Self-improvement
- It stores knowledge as Knowledge Items from conversations and work.
- Agents can reuse previous work with memory.

Product structure: Editor + Agent Manager

Antigravity centers around two screens.

Editor View
- Similar to a typical AI IDE
- Tab completions, command-based code generation, and a side panel agent
Agent Manager View
- A mission-control style view for multiple agents
- Parallel management across multiple workspaces
- Progress tracking centered on artifacts and results

This structure embodies "agents lead and humans manage."

Key features of Antigravity

1) Artifact-centric communication

Artifacts are results created by agents (task lists, implementation plans, screenshots, browser logs, and more). The key is delivering structured outputs that show what the agent did and verified.

2) Browser Subagent

A dedicated subagent runs when the agent needs to control a browser.

Tools for clicking, scrolling, typing, and reading logs
An overlay to indicate user input is restricted
Can run in background tabs

In short, browser testing is a first-class feature.

3) Knowledge Items

Antigravity turns conversations and work into ongoing knowledge items.

A summary of a topic and related artifacts
Visible in Agent Manager
Agents can reference it later

4) MCP integration

Antigravity supports MCP (Model Context Protocol).

Standardized connections to external databases and services
Install and authenticate servers via the MCP store
Supports GitHub, Notion, Supabase, Stripe, and more

This means agents can access context outside of code by default.

5) Secure Mode

Secure Mode manages security and risk.

Browser allowlist/denylist
Terminal/JS execution always requires user confirmation
Artifact-based execution requires manual approval
Respects .gitignore and blocks access outside the workspace

This makes agent automation more practical for enterprise environments.

Use case summary

Antigravity highlights the following user scenarios.

Professional developers: codebase investigation, backlog processing, parallel background agents
Frontend developers: browser-driven testing and visual feedback with screenshots/videos
Fullstack developers: higher trust and handoff through artifacts and verification

Real-world examples: how far can it go?

The official product and use-case pages give a sense of scale.

Product demo examples: Auto-playing Pinball Machine, Flight Tracker App, Inverted Pendulum Controller, Collaborative Whiteboard App
Professional scenarios: background agents for codebase investigation, bug fixes, backlog tasks
Frontend scenarios: browser-based testing with screenshots/videos for feedback
Fullstack scenarios: trust design centered on artifacts and verification, plus Editor/Manager handoffs
Liftoff Series videos: explain collaboration between Editor and Manager, browser-based frontend verification, and artifact-based workflows

In short, Antigravity goes beyond "code autocomplete" to a design where agents lead the entire plan-build-verify-feedback cycle.

Model updates: Gemini 3 Flash, Nano Banana Pro

Recent blog posts show that model updates are part of the Antigravity experience.

Gemini 3 Flash: a speed-focused model to accelerate agent loops
Nano Banana Pro (Gemini 3 Pro Image): improved quality for UI mockups, diagrams, and image assets

This means Antigravity treats model selection and updates as part of the product experience, not just the IDE.

Pricing and plan structure

Based on the pricing page, these plans are available.

Individual (Public Preview): free, includes Gemini 3 Pro/Flash
Developer (Google One): higher rate limits
Team (Google Workspace): organization scale
Organization (Google Cloud): enterprise plan (coming soon)

How is it different from other coding agents?

Positioning statements say Cursor is "the most productive way to code with AI," Windsurf is "Flow in an agent IDE," and Devin is "AI software engineer." Antigravity is unique in emphasizing agent management and artifact-based verification.

The product structure itself is different
- Dual structure: editor + manager
- Running multiple agents in parallel is a default experience
Artifact- and verification-centered trust
- Results-based communication instead of simple logs or diffs
Browser automation as a first-class feature
- Dedicated Browser Subagent
- Testing and verification loops are part of the product
Continuous knowledge accumulation
- Knowledge Items to structure work memory
MCP-based external context connections
- Standardized external service connections
Secure mode built in
- Built-in controls for automation risk

In short, Antigravity makes "agents lead and users supervise/feedback" the core of the product.

Getting started: download and supported environments

According to the docs, supported environments are:

macOS (current and previous two versions, minimum 12 Monterey)
Windows 10 64-bit
Linux (glibc >= 2.28)

For details, see the official docs.

Wrap up

Antigravity is not just a "smarter agent." It looks like an attempt to change the shape of the development environment itself to be agent-centric. If you are curious where AI IDEs are heading, Antigravity is a useful case to study.

Quokka Labs blog

Google Antigravity and the direction of agent-first IDEs