Google Antigravity is an agent-first development environment: instead of only offering autocomplete or a chat sidebar, it gives you AI agents that can plan, edit your code, run terminal commands, and even use a browser to verify results. Google frames it as moving from “help me write code faster” to “help me orchestrate software tasks end-to-end.”
(If you’ve used Cursor / Copilot, Antigravity feels closer to “mission control” for agents than a traditional assistant.)
This post focuses on the two questions everyone asks after the first hour:
1) What are the core features that matter in practice?
2) What do the rate limits/quotas mean, and how do you avoid hitting them?
1) The core ideas: why Antigravity is “agent-first”
Agents can work across editor, terminal, and browser
The defining capability is multi-tool autonomy: you can ask an agent to implement a feature, run tests/build commands, open the app, and validate behavior — all within one workflow. Google describes this explicitly as execution across your editor, terminal, and browser.
This “multi-surface” model is the reason Antigravity feels different from prompt-in/answer-out chat tools: it’s designed for tasks that normally require context switching.
Two primary views: Editor View + Manager Surface
Google highlights two main ways to use the product:
- Editor View: the “classic IDE loop” (write code, inline commands, tab completions).
- Manager Surface: the “agent orchestration loop” (spawn multiple agents, observe progress, dispatch long-running tasks).
If you’re building something bigger than a single file, the Manager Surface is what makes the product feel “agentic” rather than “chat with a code window.”
Trust via “Artifacts”
Agent tools can be scary because a plain tool log is hard to audit. Antigravity’s answer is Artifacts: tangible outputs (task lists, implementation plans, screenshots, browser recordings) that let you validate the agent’s work faster than reading raw logs.
This matters a lot when you:
- delegate a UI rework and want screenshots,
- ask for a bug reproduction and want steps + evidence,
- request a refactor and want a summarized diff/plan.
2) Model choice: what you can run inside Antigravity
Antigravity supports “model optionality.” Official docs list several models and variants (including different “reasoning”/“thinking” modes). In public preview, the commonly highlighted options include:
- Gemini 3 Pro
- Claude Sonnet 4.5 (and thinking variants)
- GPT-OSS variants
In practice: pick the model based on the task.
- Fast iterations / UI tweaks → faster model or lower reasoning setting.
- Hard refactors, tricky bugs → stronger reasoning setting (slower, but fewer iterations).
- Huge repo analysis → plan first, then implement in slices (more below).
3) Rules and workflows: how to make the agent behave consistently
One of the easiest “productivity multipliers” is using Rules (persistent instructions) so you stop repeating yourself.
Where rules live (important)
Antigravity supports:
-
Global Rules:
~/.gemini/GEMINI.md(applies everywhere) -
Workspace Rules:
.agent/rules/*.mdinside your repo (applies only to that project)
This split matters because:
- Global rules are great for universal preferences (language, style, safety).
- Workspace rules are great for repo-specific conventions.
Examples of practical rules
Comments in English
All code comments MUST be written in English.
Chat explanations may be in French, but code comments must be English only.
Confirm before editing files
Before modifying/creating/deleting files, propose a plan or diff and ask for my explicit confirmation.
Do not edit files until I reply “yes”.
Confirm before running terminal commands
Never run terminal commands without asking for approval first.
Show the exact command(s) you want to run and explain why.
These rules reduce wasted quota because the agent stops “thrashing” with rework and ambiguity.
Antigravity is free (public preview), but rate-limited
Google states Antigravity is available in public preview at no cost for individuals. That does not mean unlimited usage: the system is rate-limited to protect capacity.
Think of it as a “fuel tank” that refills on a schedule.
The key detail you can know: refresh schedules
Google has publicly described a tiered refresh approach:
- Free plan: a weekly-based rate limit refresh (“larger weekly limit” so you don’t hit the cap too quickly mid-project).
- Google AI Pro / Ultra: higher rate limits that refresh every five hours, with “priority access.”
This is the single most important “quota fact” because it tells you what happens when you hit the cap:
- Free users: you may need to wait until the weekly refresh.
- Pro/Ultra: the window resets frequently (every ~5 hours), so you can keep iterating the same day.
Why you can’t reduce quota to “X prompts”
Google’s own description is that usage correlates with the “work done” by the agent — not simply “messages sent.”
That’s why one prompt can be “cheap” (small code change), while another can be “expensive” (plan + multi-file edits + tests + browser validation).
5) What tends to consume quota faster (practical heuristics)
Antigravity doesn’t publish an exact “tokens remaining” meter (at least not as a documented feature), so you have to optimize based on workflow.
Here’s what usually burns quota fast:
Heavy (“expensive”) actions
- Large repo-wide analysis (“scan everything, redesign architecture”)
- Big multi-file refactors in one go
- Long agent runs that:
- call the terminal repeatedly,
- browse a lot,
- generate large Artifacts (screenshots/recordings),
- rerun tests multiple times
Light (“cheap”) actions
- Small scoped code edits (1–3 files)
- Focused bug fixes with a reproducible snippet
- Incremental iteration (plan → implement → test)
If you’re building a small vanilla TS project (flashcards/quiz), you can usually keep usage “light” by staying disciplined.
6) How to avoid hitting rate limits while building real projects
This is the playbook that consistently helps:
1) Ask for a plan before you ask for edits
Instead of:
“Refactor the whole app.”
Do:
“Propose a refactor plan + file-by-file diff outline. Wait for my ‘yes’ before editing.”
You’ll catch wrong assumptions early and waste fewer agent cycles.
2) Keep context tight
If you paste or attach files, keep it to the minimal set:
- the broken file,
- the file that calls it,
- the relevant data/types.
(For example: data.ts, flashcards.ts, and maybe index.html.)
3) Slice work into “small commits”
A good pattern:
- Step 1: Add deck selector UI (only HTML/CSS).
- Step 2: Wire selector to state (only TS).
- Step 3: Add quiz mode (TS + small CSS).
- Step 4: Polish UX (CSS only).
This keeps each agent run bounded.
4) Use Rules to reduce back-and-forth
Rules like “comments in English” and “confirm before edits/commands” reduce the number of “oops, redo this” loops — which is one of the biggest quota killers.
7) What errors look like when you hit the quota
When you run out of quota, you typically see errors along the lines of:
- “rate limit exceeded”
- “quota exceeded”
- “model quota limit exceeded”
The practical takeaway is:
- you can’t “ask the agent how many requests are left” reliably,
- you can design your workflow to avoid the cap.
8) Antigravity quota vs Gemini API billing (don’t confuse them)
Antigravity (preview) is positioned as no cost for individuals, but it’s rate-limited. That’s different from:
- using Gemini via API/Vertex AI, which is usage-billed (tokens/requests),
- where quotas can often be increased by changing limits and paying.
If you need predictable high-volume throughput (batch processing, many runs per day), the API route is usually the “scalable” path. Antigravity is optimized for interactive dev and agent workflows.
TL;DR
- Antigravity is an agent-first platform: agents can plan + implement + test across editor/terminal/browser.
- Trust is improved via Artifacts (plans, screenshots, recordings).
- You can shape behavior with Rules (global + workspace) and avoid repeating constraints.
- Antigravity is free in preview but rate-limited:
- Free users: weekly refresh cycle.
- AI Pro/Ultra: 5-hour refresh cycle and priority access.
- There’s no simple “1 prompt = 1 unit” formula because usage correlates with work done.
- Best way to avoid limits: small scoped tasks + plan-first + rules + incremental changes.
Sources (official / primary where possible)
- Google Developers Blog: “Build with Google Antigravity, our new agentic development platform” (Nov 20, 2025)
- Google Blog (The Keyword / Feed): rate-limit update for Pro/Ultra + weekly free refresh (Dec 2025)
- Google One Support: Google AI Pro benefits including Antigravity refresh every 5 hours (French help page)
- Antigravity docs: Models, Rules & Workflows (product documentation)
Top comments (0)