Antigravity CLI vs Gemini CLI: Getting Started Guide for Developers in India

If you installed Gemini CLI last year because it was free, the command you remember may no longer be the one to use. For individuals, Google replaced Gemini CLI with Antigravity CLI, run as agy; Gemini CLI itself stays for people with paid API keys or organization licenses. This guide sorts out which one fits you, whether you can use it from India, how to install it, how to move your setup across, and how to set permissions before it touches your code.

I read Google's own pages on 2026-10-09: the developers blog announcement, the Antigravity docs (getting started, installation, migration, plans, permissions, headless mode, FAQ), geminicli.com and the Gemini CLI README. I also downloaded the Linux build of Antigravity CLI, verified its checksum and ran its help screens in a throwaway home directory. I could not sign in, so I never ran an actual prompt. Everything about model behaviour is therefore from Google's text, not my testing.

For how this fits next to Codex and Claude Code, see the three-way CLI comparison. This post goes deeper on the Google side and on India.

What changed, and where do Google's pages disagree?

The announcement is dated 19 May 2026. Its key points:

• Antigravity CLI became available to everyone that day. It is built in Go and shares one agent harness with the Antigravity 2.0 desktop app.
• On 18 June 2026, Gemini CLI and the Gemini Code Assist IDE extensions stop serving requests for Google AI Pro and Ultra, and for Gemini Code Assist for individuals used free.
• Enterprise licenses (Gemini Code Assist Standard or Enterprise) keep access unchanged. Gemini CLI stays reachable "via paid Gemini and Gemini Enterprise Agent Platform API keys".
• Google says there is no 1:1 feature parity at launch. Agent Skills, Hooks, Subagents and Extensions (now plugins) are kept.

The geminicli.com banner repeats it: unpaid-tier and Google One users were moved on 18 June 2026. Then the pages start contradicting each other:

When docs conflict, test on your install before you build a team workflow around either claim.

Which one should you use?

If you also use Claude Code or Codex, you do not have to pick one. A shared AGENTS.md can feed all of them (Claude Code needs a one-line import); see AGENTS.md vs CLAUDE.md vs .cursorrules.

Can you use Antigravity CLI in India?

Per the FAQ on 2026-10-09:

• India is on the list of available countries and territories (under Asia).
• It is available for personal Google accounts in approved geographies. If a Google Workspace account fails, the FAQ suggests an @gmail.com address.
• You must be 18 or over; there is an age verification step.
• The FAQ says to check the country on your Google Terms of Service page, and that you can request a region change if it is wrong.
• India is not on the FAQ's list of regions without Google One AI plans.

What I could not find: a rupee price for Google AI Pro or Ultra, or a statement about card or UPI payment. Those are on Google One's pages and vary. Do not buy anything because of a blog post, including this one.

On data: the FAQ says to refer to the Terms of Service and that you can opt out of data collection from the Settings panel. Read that before pointing the agent at client code. For how vendors differ, see the data retention and training opt-out table.

How do you install Antigravity CLI?

The documented commands:

# macOS, Linux, Googlebook
curl -fsSL https://antigravity.google/cli/install.sh | bash

# Windows PowerShell
irm https://antigravity.google/cli/install.ps1 | iex

The installer puts the agy binary at ~/.local/bin/agy on macOS and Linux, and under C:\Users\<username>\AppData\Local\agy\bin on Windows. It accepts --skip-aliases and --skip-path if you do not want it editing your shell profile.

Piping a script into a shell is a habit worth breaking, so I read the Unix script first. It does this, in order: detects your OS and CPU (including a musl Linux build and Android/Termux), fetches a JSON manifest from a Google-run service, downloads a tar.gz from storage.googleapis.com, compares its SHA-512 to the manifest and aborts on mismatch, copies the binary to ~/.local/bin (or --dir), then runs agy install to configure your PATH.

If you prefer to inspect first:

curl -fsSL https://antigravity.google/cli/install.sh -o install.sh
less install.sh
bash install.sh

I did not run the installer on my machine. I downloaded the Linux x64 build it points to (manifest version 1.3.2 on 2026-10-09), confirmed the SHA-512 matched the manifest, and ran the binary with HOME set to an empty scratch folder. Its help screen lists these subcommands: agents, changelog, install, mcp, models, plugin, remote-control, update, plus mic-serve. Top-level flags include -p/--print, --output-format, --json-schema, --mode (accept-edits or plan), --effort, --model, --sandbox and --dangerously-skip-permissions. Running agy models or agy -p "say hi" without credentials printed a sign-in message and a Google OAuth URL and waited for a code, as the docs describe.

First launch and signing in

Run agy inside a project folder. The first launch asks for a colour scheme, a rendering mode (alt-screen or inline) and whether you trust the workspace. Sign-in opens a browser. Over SSH, for example on a VPS, the CLI prints a URL; open it on your laptop, sign in, and paste the code it shows back into the SSH session. Credentials go to your operating system's keyring when one is available.

How do you move a Gemini CLI setup across?

Google's migration page says the first agy launch detects legacy profiles and offers a checklist. It also lists what you may have to do by hand:

The binary's own help says plugin import [source] imports "from gemini or claude". I did not run either import, so I cannot say what the Claude one converts.

Because the manual parts are easy to forget, here is a read-only checker. It reports what needs moving and prints a proposed mcp_config.json. It changes nothing.

#!/usr/bin/env python3
"""List what a Gemini CLI setup needs before Antigravity CLI (agy) will see it.

Based on Google's "Migrating from Gemini CLI" page (read 2026-10-09):
  - workspace skills move from .gemini/skills/ to .agents/skills/
  - global skills move from ~/.gemini/skills/ to ~/.gemini/antigravity-cli/skills/
  - MCP servers move out of ~/.gemini/settings.json into mcp_config.json
    (global: ~/.gemini/config/mcp_config.json, workspace: .agents/mcp_config.json)
  - remote MCP keys `url` / `httpUrl` become `serverUrl`
  - GEMINI.md and AGENTS.md need no changes
It only reads files and prints a report. It changes nothing.
"""
import argparse
import json
from pathlib import Path

REMOTE_KEYS = ("url", "httpUrl")


def skills(base: Path, label: str, target: str, notes: list[str]) -> None:
    folder = base / "skills"
    if folder.is_dir():
        names = sorted(p.name for p in folder.iterdir())
        notes.append(f"MOVE   {label} skills {names} -> {target}")


def mcp(settings_file: Path, label: str, notes: list[str]) -> None:
    if not settings_file.is_file():
        return
    try:
        data = json.loads(settings_file.read_text(encoding="utf-8"))
    except json.JSONDecodeError as exc:
        notes.append(f"CHECK  {settings_file} is not valid JSON ({exc.msg}, line {exc.lineno})")
        return
    servers = data.get("mcpServers") or {}
    if not servers:
        return
    out = {}
    for name, cfg in servers.items():
        cfg = dict(cfg)
        for key in REMOTE_KEYS:
            if key in cfg:
                cfg["serverUrl"] = cfg.pop(key)
                notes.append(f"RENAME {label} server {name!r}: {key} -> serverUrl")
        if "serverUrl" not in cfg:
            notes.append(f"VERIFY {label} server {name!r} has no remote URL; copied unchanged, check the schema")
        out[name] = cfg
    notes.append(f"WRITE  {label} proposed mcp_config.json:\n" + json.dumps({"mcpServers": out}, indent=2))


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--home", default=str(Path.home()))
    ap.add_argument("--project", default=".")
    args = ap.parse_args()
    home, project = Path(args.home), Path(args.project)
    notes: list[str] = []

    skills(project / ".gemini", "workspace", str(project / ".agents/skills/"), notes)
    skills(home / ".gemini", "global", str(home / ".gemini/antigravity-cli/skills/"), notes)
    mcp(home / ".gemini/settings.json", "global", notes)
    mcp(project / ".gemini/settings.json", "workspace", notes)

    for ctx in (project / "GEMINI.md", project / "AGENTS.md", home / ".gemini/GEMINI.md"):
        if ctx.is_file():
            notes.append(f"OK     {ctx} needs no change")
    notes.append("RUN    agy plugin import gemini   (converts Gemini extensions to plugins)")
    print("\n".join(notes))


if __name__ == "__main__":
    main()

I ran it against a fixture: a fake home with a settings.json holding three MCP servers (one using httpUrl, one url with an env block, one local command server), plus a project with one skill under .gemini/skills/ and an AGENTS.md. The output:

MOVE   workspace skills ['review-pr'] -> /tmp/T1/fixture/proj/.agents/skills
RENAME global server 'docs-search': httpUrl -> serverUrl
RENAME global server 'issue-tracker': url -> serverUrl
VERIFY global server 'local-files' has no remote URL; copied unchanged, check the schema
WRITE  global proposed mcp_config.json:
{ ...three servers, the two remote ones now using serverUrl... }
OK     /tmp/T1/fixture/proj/AGENTS.md needs no change
OK     /tmp/T1/fixture/home/.gemini/GEMINI.md needs no change
RUN    agy plugin import gemini   (converts Gemini extensions to plugins)

(I shortened the JSON block here; the script prints it in full.) The migration page only documents the schema change for remote servers. For local command servers I copied the entry unchanged and flagged it, because I could not confirm the schema. Also note that Google's example mentions only a global settings.json; the workspace-level check in my script is an extra that costs nothing if the file is absent.

How do you set permissions before the first real task?

Do this before you hand the agent a repo. The CLI keeps three lists in ~/.gemini/antigravity-cli/settings.json: deny, ask and allow, with rules written as action(target). Precedence is deny, then ask, then allow, so a broad ask rule beats a narrow allow. Supported actions include read_file, write_file, read_url, execute_url, command and mcp; command accepts a prefix or a regex: pattern.

A starting point. The syntax follows Google's examples; I parsed the JSON but did not load it into a live agy:

{
  "permissions": {
    "allow": [
      "command(git status)",
      "command(git diff)",
      "command(regex:npm run (build|lint|test))"
    ],
    "deny": [
      "command(rm -rf)",
      "command(sudo)",
      "write_file(.git/)",
      "write_file(.env)"
    ],
    "ask": [
      "command(git push)",
      "mcp(*)"
    ]
  }
}

What the docs say about defaults, and where they are unclear:

• Reading and writing files inside the workspace is allowed without a prompt. Files outside it, web browsing and MCP calls default to ask.
• Shell commands: the CLI section says unconfigured commands default to ask. The macOS/Linux section of the same page shows a "Default" preset where commands run in an isolated terminal sandbox (workspace and temp folders, no network) without prompting, and ask only outside it. The Windows section describes the older system. These can both be true for different surfaces or versions, so run the permissions command in your install and read what it says.
• If a command contains tricks like $(...), backticks or git -c core.pager=..., prefix rules stop applying and only an exact full-line match runs unprompted.
• In headless mode, anything that needs approval is soft-denied: the run continues, exits 0, and prints a notice to stderr. A green exit code does not mean the command ran.

--dangerously-skip-permissions approves everything. Keep it for disposable containers. The same advice and a layered setup are in AI coding agent safety.

Can you script it in CI?

Yes: agy -p "prompt" runs once and exits. Per the headless page, --output-format takes text (default), json (one envelope) or stream-json. The JSON envelope has status, response, error, duration_seconds, num_turns, usage and, with --json-schema, structured_output. Headless runs use cached credentials, so authenticate once interactively first or use the API-key route. The docs say an unauthenticated run in an environment with no terminal exits with an authentication error instead of hanging. In my test, with stdin from /dev/null, agy -p printed a sign-in URL and sat waiting for a code until I stopped it at 20 seconds, so do not count on a fast failure in CI.

result=$(agy -p "Summarise the risks in this diff" --output-format json --print-timeout 10m)
status=$(echo "$result" | jq -r '.status')
[ "$status" = "SUCCESS" ] || { echo "$result" | jq -r '.error' >&2; exit 1; }
echo "$result" | jq -r '.response'

That snippet is adapted from Google's CI example and is unrun, since I had no credentials. Two cautions from the FAQ: headless mode is meant for direct scripting, and wrapping it inside other coding agents or rotating accounts is not supported on consumer plans.

What are the limits and costs?

The Plans page gives structure, not prices. All plans get Gemini models as the core agent, unlimited Tab completions and access to features including the CLI. People not on Google AI Pro or Ultra get "a meaningful quota, refreshed weekly" and a weekly rate limit. Pro gets a quota refreshed every five hours until a higher weekly limit is reached. Ultra gets the highest limits and third-party models. Pro and Ultra users can spend purchased AI credits for overage, controlled by an "AI Credit Overages" setting (Never or Always). The page says limits depend on capacity and can change, and that heavier tasks use more quota. It gives no request counts.

What goes wrong most often?

What I could not verify

• I never signed in, so I did not run a prompt, measure quota or test any permission rule.
• The API-key route and the Plans page conflict; I did not resolve it.
• I did not run the installer, agy plugin import, or the Gemini CLI itself.
• No rupee prices, no payment-method details and no model-quality claims appear here because I found none on a primary page.
• Google changes these pages often. The date on this post is the only guarantee of freshness.