How to Use Gemini 4 Argon in Antigravity With /goal and Skills

Gemini 4 Argon runs inside Google Antigravity today, but only for two groups: Google AI Ultra subscribers and enterprise customers. If you're on Google AI Pro, you get Argon in the Gemini app and in AI Mode in Search, not in Antigravity. Developers who just want the model can call it through the paid tier of the Gemini API in AI Studio and Android Studio.

Once you have it, the workflow Google describes at launch is short. You hand Argon a goal with the /goal slash command, give it a rulebook under .agents/skills so it knows your conventions, and for anything that's hard to judge automatically, you prompt it to run a multi-agent critique loop built from custom skills. Below is each step, what the official launch material actually documents, and where you'll need to make your own calls.

Who gets Gemini 4 Argon in Antigravity#

Access depends on which door you come through. This is what the launch post lists.

Two details matter if you're in the last two rows. The researcher program onboards on a rolling basis and is subject to eligibility, capacity, and selection, so an application isn't a guarantee. The Fairwind Program is also rolling, and Google says it's expanding to hundreds of additional partners rather than opening to everyone.

If you're a solo developer deciding whether Ultra is worth it just for Argon in Antigravity, the honest answer is that the launch post gives you Google's own internal numbers and nothing else. Teams there saw agentic code submissions go up by more than 35% while rollbacks dropped by nearly a third. Your results will depend on your codebase and on how well you set up the next three sections.

Start with /goal instead of a chat message#

Antigravity has slash commands, and /goal is the one Google calls out for Argon. The pattern in the launch post is consistent: a team writes a short goal, attaches a rulebook, and lets Argon work for an extended stretch. The Agent Development Kit team gave Argon their .agents/skills rulebook plus a one-paragraph goal to eliminate framework overhead without breaking existing apps, then let it run overnight. The optimizations it surfaced are now live in google/adk-python, cutting in-memory session prep time by 40% in long sessions and speeding up cold imports by 21%.

The useful part of that story isn't the numbers. It's the shape of the goal. One paragraph, one outcome, one hard constraint. I'd write every /goal the same way:

/goal Reduce per-request overhead in the session layer of this service.
Measure with the existing benchmark in bench/session_bench.py and report
before/after numbers. Hard constraint: no public API changes, no new
runtime dependencies, and the full test suite must pass. Stop and ask
before touching anything under migrations/.

Three things to notice. The outcome is measurable, so Argon can tell when it's done. The constraint is explicit, which matters because Google trained Argon to respect system boundaries and report negative findings honestly, so it will tell you when a goal and a constraint conflict instead of quietly bending one. And the "stop and ask" line relies on behavior Google built in on purpose: Argon pauses for human confirmation before irreversible steps.

The launch material doesn't document flags or options for /goal, so I'm not going to list any. Treat it as "goal in plain language" until the Antigravity docs say otherwise.

Writing a rulebook under .agents/skills#

A rulebook is the standing context Argon reads before it starts. Google's own example is the ADK team's .agents/skills folder, which is what let a one-paragraph goal turn into a night of useful work. Without it, Argon has to infer your test command, your style, and your no-go zones from the code, and it'll get some of that wrong.

The launch post doesn't specify a file format, so I keep rulebooks as plain Markdown and keep each one focused on a single concern: how to verify changes, what not to touch, what "done" means. Google says Argon follows style instructions better than any previous Gemini model, so instructions about output format and tone also belong here.

Here's a small generator that prints a starter rulebook. Edit the dictionary for your project and paste the output into a file under .agents/skills.

# Print a starter rulebook for .agents/skills.
# Edit the dict, run it, paste the output into your repo.
project = {
    "name": "session-service",
    "language": "Python 3.12",
    "test_command": "python -m pytest -q",
    "lint_command": "ruff check .",
    "never_touch": ["migrations/", "vendor/", "public API signatures"],
    "done_when": [
        "all existing tests pass",
        "no new runtime dependencies",
        "a short CHANGES note explains each optimization",
    ],
}

lines = [f"# Rulebook: {project['name']}", ""]
lines += ["## Stack", f"- {project['language']}", ""]
lines += ["## Verify every change",
          f"- Run `{project['test_command']}`",
          f"- Run `{project['lint_command']}`", ""]
lines += ["## Do not touch"] + [f"- {x}" for x in project["never_touch"]] + [""]
lines += ["## Definition of done"] + [f"- {x}" for x in project["done_when"]]
print("\n".join(lines))

A few rules of thumb from writing these:

• Put commands, not descriptions. "Run python -m pytest -q" beats "make sure tests pass."
• Name the files or folders that are off limits. Argon is good at respecting boundaries it can see.
• State the definition of done as a checklist. This is what the critic will use in the next section.
• Keep it short. A rulebook that reads like a policy manual gets skimmed by humans and models alike.

Setting up a multi-agent critique loop with custom skills#

This is the part of the launch most people are asking about. Google's demos of Argon in Antigravity all use the same construct: one agent builds, another critiques against a rubric, and the loop repeats until the critic is satisfied. The Pagoda temple complex, the desk-to-racing-game demo, and the procedurally sculpted 3D game were all produced with what Google calls multi-agent visual critique loops, driving Blender MCP for modeling and collision checks, Nano Banana for textures, and Three.js for the web build.

You don't get a dedicated "critique loop" button. You get custom skills plus prompting. The launch post says exactly that: "slash commands like /goal and prompting for multi-agent loops with custom skills." So the setup is two skills and a goal that ties them together.

The builder skill says what to produce and which tools to use. The critic skill says how to judge it: a rubric with named criteria, a required output format (pass, or a ranked list of specific defects), and a rule that "looks good" is not an acceptable review. The goal then says: build, critique, revise, and stop when the critic passes or after N rounds.

Here's the control flow written out in plain Python so you can see what you're asking Argon to run. It's a simulation, not a model call, but the stopping logic is the part that matters.

# A critique loop in miniature: builder revises, critic scores,
# loop stops on pass or at the round cap. Deterministic, no model calls.
RUBRIC = {"proportions": 3, "lighting": 2, "collisions": 3}
MAX_ROUNDS = 5

def build(state, feedback):
    # Pretend the builder fixes the flagged item each round.
    if feedback:
        state[feedback] = min(RUBRIC[feedback], state[feedback] + 2)
    return state

def critique(state):
    gaps = {k: RUBRIC[k] - v for k, v in state.items() if v < RUBRIC[k]}
    if not gaps:
        return None
    return max(gaps, key=gaps.get)

state = {"proportions": 0, "lighting": 1, "collisions": 0}
feedback = None
for rnd in range(1, MAX_ROUNDS + 1):
    state = build(state, feedback)
    feedback = critique(state)
    print(f"round {rnd}: {state} -> critic says: {feedback or 'PASS'}")
    if feedback is None:
        break
else:
    print(f"stopped at the {MAX_ROUNDS}-round cap; escalate to a human")

Notice the two exits. The loop ends when the critic has nothing left to flag, or when it hits the round cap and escalates. If you prompt a loop with only the first exit, you've built something that can run until your usage tier runs out. Put the cap in the goal text, not just in your head.

For visual work, the critic needs to actually see the output. In Google's demos that means rendering a frame or a screenshot each round and feeding it back. Spatial reasoning, mathematical precision, and visual coding are where Google says Argon improved most over previous Gemini models, which is why the critic role works at all for 3D scenes.

What Argon costs if you also use the API#

Antigravity usage is covered by your Ultra or enterprise plan, so this section only matters if you want the same model in your own scripts or CI. The API price at launch is introductory: $2 per million input tokens and $10 per million output tokens, with cached input tokens at 95% off. After the introductory period expires on November 30, 2026, the price moves to $4 per 1M input tokens and $20 per 1M output tokens. That applies to the Argon model intended for public access. The current numbers live on the Gemini API pricing page.

Argon also has a 1M unified input-output token limit via the Gemini API, and Google points to a new continuation protocol in the Gemini API documentation for long-running work. Read that before you plan an overnight job through the API rather than through Antigravity.

// Gemini 4 Argon API cost at the introductory price (through Nov 30, 2026)
// vs. the standard price after. Antigravity usage is covered by your plan,
// so this only matters if you also call the API directly.
const perMillion = {
  intro:    { input: 2, output: 10 },
  standard: { input: 4, output: 20 },
};
const cachedDiscount = 0.95; // cached input tokens are 95% off

function cost(tier, inputTokens, cachedTokens, outputTokens) {
  const p = perMillion[tier];
  const fresh = (inputTokens - cachedTokens) / 1e6 * p.input;
  const cached = cachedTokens / 1e6 * p.input * (1 - cachedDiscount);
  const out = outputTokens / 1e6 * p.output;
  return (fresh + cached + out).toFixed(2);
}

// Example: a long refactor session that reads 800k tokens of code,
// 600k of which hit the cache, and writes 150k tokens.
for (const tier of ["intro", "standard"]) {
  console.log(`${tier}: $${cost(tier, 800_000, 600_000, 150_000)}`);
}

Caching matters more than it looks. A rulebook plus a large codebase is a lot of repeated input, and the 95% discount on cached input is the difference between a long session being cheap or not.

Common mistakes and gotchas#

• Expecting Argon in Antigravity on AI Pro. Pro gets the Gemini app and AI Mode in Search. Antigravity access is Ultra and enterprise.
• Writing a goal without a definition of done. Argon works longer and harder than previous models, which is great when the target is clear and expensive when it isn't.
• Treating the rulebook as a wish list. It needs the commands to verify a change, not adjectives about quality.
• Running a critique loop with no round cap or escalation path. The loop needs two exits, not one.
• Letting the critic grade its own work. Two skills with different instructions is the whole point. A single agent asked to "check your work" is not a critique loop.
• Planning an unattended run that needs irreversible steps. Argon pauses for human confirmation before those by design. If nobody is there, the run sits waiting. Either keep irreversible steps out of the goal or check in.
• Assuming prompt injection is solved. Argon leads the Gray Swan Indirect Prompt Injection benchmark with attack success cut to 0.7% across 15 adaptive attempts. That's strong, not zero. If the loop reads web pages, emails, or third-party code, keep the rulebook's no-go zones tight anyway.
• Budgeting at the launch price. The $2 and $10 rates end on November 30, 2026.

Quick reference#

• Access: Google AI Ultra or an enterprise plan for Antigravity. Pro gets the Gemini app and AI Mode in Search only.
• Goal: use /goal with one paragraph covering the outcome, how to measure it, hard constraints, and where to stop and ask.
• Rulebook: Markdown under .agents/skills with verify commands, no-go paths, and a definition of done.
• Critique loop: two custom skills (builder and critic), a rubric, a required critic output format, a round cap, and an escalation step.
• Visual work: render each round so the critic can see it. Google's demos used Blender MCP, Nano Banana, and Three.js.
• Unattended runs: keep irreversible steps out, or expect Argon to pause for confirmation.
• API: $2 per million input tokens and $10 per million output tokens at launch, cached input 95% off, 1M unified token limit, standard pricing from November 30, 2026.

Quick answers