When Google rolled out Gemini 3 this week, it didn’t just ship a new model — it shipped a new way of thinking about how code gets written. Antigravity, Google’s freshly announced development platform, treats AI not as a passive assistant but as an active, addressable worker: spawn agents, give them access to your editor, terminal, and browser, and watch them carry out whole tasks more like junior devs than chat helpers.

What Antigravity actually is

At its core, Antigravity reframes the IDE. Instead of a single chat box that suggests snippets, you get multiple autonomous agents that can be dropped into an editor or into a separate orchestration surface to run semi-independently. Google pitches this as an “agent-first” future — developers move from micro-prompting to spawning and supervising agents that can investigate, modify, test, and document code across workspaces.

Artifacts: the verification scaffolding

One of Antigravity’s cleverest design choices is what Google calls Artifacts. Rather than force users to scroll through opaque logs or a wall of tool calls, agents produce bite-sized, verifiable checkpoints: task lists, implementation plans, diffs, screenshots, and even browser recordings. The idea is simple and persuasive — give humans digestible proof of intent and result so they can verify work without replaying every single internal action. Google says Artifacts are intended to be easier for users to verify than raw tool-call histories.

Two modes: Editor view and Manager view

Antigravity ships with two distinct interfaces. The default Editor view looks and feels familiar: it’s an IDE with a context-aware agent sitting in a side panel, offering inline suggestions, tab completion, and natural-language commands. The Manager view is the bigger change — imagine a mission control dashboard where a lead engineer can spawn, monitor, and orchestrate dozens of agents across multiple workspaces in parallel. Google leans into the analogy: Manager is “mission control” for agent-based development. That parallel surface is aimed at teams who want to run several asynchronous workflows at once.

Feedback, memory, and incremental learning

Antigravity lets you give feedback without interrupting an agent’s flow. You can comment directly on specific Artifacts — like annotating a PR — and the agent will take that feedback into account as it continues. Google also says agents can “learn from past work,” retaining snippets or procedural steps so repeating patterns become faster and less error-prone over time. It’s not magic; it’s a versioned, context-aware memory that aims to reduce repetitive hand-holding.

Models, limits, and who can use it

Antigravity is built around Gemini 3 Pro but is model-agnostic enough to plug in other third-party models — Google lists support for Claude Sonnet 4.5 and OpenAI’s GPT-OSS as examples. The platform is in public preview now for Windows, macOS, and Linux and is free to use with what Google describes as “generous rate limits” for Gemini 3 Pro; those limits refresh periodically (Google says roughly every five hours) and, in their words, only “a very small fraction of power users” will hit them.

Why Google built this — and why it matters

The obvious sales pitch is productivity: agents that can run tests, refactor code, and assemble UI prototypes while you focus on architecture or edge cases are a force multiplier. But there’s a subtler product bet here: if agents are going to be writing production-grade code, teams will need good ways to verify, audit, and steer them. Artifacts, the Manager view, and commentable checkpoints are Google’s attempt to make that workflow legible and collaborative — not a black box.

The tradeoffs and the questions

For every benefit, there’s a new governance and ergonomics problem. Who owns an agent’s decisions when it modifies production code? How do teams manage secrets, dependency upgrades, or subtle semantic bugs that an agent introduces? Antigravity’s artifact model helps with traceability, but legal, security, and workflow questions remain for orgs that will want more than a screenshot and a task list before merging changes into master. Industry reaction so far has been a mix of excitement and cautious pragmatism: this is clearly powerful, but not a turnkey replacement for human oversight.

What to try first

If you’re curious, Google’s public preview is the place to poke around: try spawning a small agent to do a targeted task (refactor a function, run tests, or draft a README), watch the Artifacts stream, and leave a few comments to see how the agent adapts. Because Antigravity can attach browser and terminal access, treat it like a new team member: start with low-risk tasks, review artifacts carefully, and use the Manager view only after you’ve established trust boundaries.

Antigravity is less a single product and more a thesis: models like Gemini 3 are getting capable enough that the next useful thing isn’t better prompts — it’s better ways to manage and verify autonomous agents. Google’s playbook combines tooling (IDE + manager), transparency (Artifacts), and model choice (Gemini 3 Pro plus third-party models). Whether teams adopt an agent-first workflow will depend on how well those pieces hold up in real engineering environments — and how quickly the ecosystem builds practices around verification, security, and responsibility.