Tag Archives: Antigravity Mastery

Token Efficiency with Antigravity: Maximizing the Free Tier

Leave a reply

Token Efficiency with Antigravity: Maximizing the Free Tier

So you’ve discovered Google Antigravity and you’re loving the agent-first workflow. You’ve delegated your first few tasks, marveled at how agents work autonomously, and started building your skill library. But there’s one catch: the free individual tier has token limits.

“Wait, what? Token limits? I thought it was free!”

Yes, Antigravity’s public preview is free—but not unlimited. Google imposes rate limits on Gemini 3 Pro (and any additional models you connect) to ensure fair usage across millions of developers. And if you’re running multiple agents simultaneously or tackling complex projects, those tokens can vanish faster than you’d expect.

This isn’t about cutting corners—it’s about working smarter. In this post, we’ll dive deep into practical strategies that help you get the most out of Antigravity’s free tier without constantly hitting your limits. We’ll cover token budgeting, artifact optimization, skill selection, task decomposition, and usage monitoring. By the end, you’ll know exactly how to stretch your free tokens further while still getting amazing results.

Understanding Token Budgeting: The 120,000 Token Reality Check

Let’s start with the numbers. Antigravity’s free tier gives you:

  • 120,000 tokens per minute for Gemini 3 Pro (shared across all active agents)

  • 50 requests per minute (rate limit, not token-based)

  • Context window: 1M tokens per agent (but you only pay for what you use)

Here’s the thing: those 120k tokens reset every minute, but they’re a hard cap. If you spawn three agents working simultaneously, they’re all drawing from the same pool. One runaway agent can consume your entire allocation before you know it.

How Antigravity Counts Tokens

Unlike simple completion-based tools (Copilot charges per line), Antigravity tracks:

1. Input tokens: Your task description + relevant context pulled from your codebase + selected skills
2. Output tokens: Agent’s responses + generated code + artifact content
3. Tool call tokens: Each time an agent reads files, searches code, or executes commands, those operations consume tokens too

A typical “refactor this function” task might use 5,000-15,000 tokens. A complex “implement OAuth with tests and docs” could easily exceed 50,000 tokens.

The Token Budget Mindset Shift

Stop thinking in tasks. Start thinking in token units.

Instead of:
> “Let me ask Antigravity to review my PR, then fix the bugs it finds, then add tests, then update docs…”

Think:
> “I have 40,000 tokens to spend today. How can I accomplish the most valuable work within that budget?”

This mental shift changes how you approach Antigravity. You become a token allocator, not just a task delegator.

Strategy 1: Artifacts Are Your Best Friend (Reduce Back-and-Forth)

Every time you and an agent go back-and-forth—asking questions, getting clarifications, fixing misunderstandings—you’re burning tokens on context carrying. The agent has to re-read the entire conversation history each time.

Artifacts solve this by making the agent’s thinking visible and reviewable upfront.

The Artifact Advantage

When an agent produces an artifact (screenshot, test report, implementation plan), it’s a tangible deliverable you can review immediately. No need to ask “what did you do?”—the artifact shows you.

More importantly, artifacts reduce conversational turns. One thorough artifact review with inline comments replaces 3-5 chat cycles.

Example: Bad vs Good Workflow

❌ Token-Guzzling Approach:

You: "Add error handling to the API endpoints"
Agent: "Which endpoints?"
You: "All user-related ones"
Agent: "What kind of errors should I handle?"
You: "Validation errors, network timeouts, database failures"
Agent: "Should I log them?"
... 4+ more exchanges ...

≈ 15,000 tokens burned on clarification.

✅ Artifact-First Approach:

You: "Add comprehensive error handling to all user-related API endpoints. Create an artifact showing:
1. Your error handling strategy (types of errors, retry logic)
2. A diagram of the error flow
3. Screenshots of the implementation
4. Test results proving it works"

Agent produces one comprehensive artifact, you review it with comments, agent iterates once.
≈ 4,000 tokens total.

Pro Tips for Artifact Efficiency

1. Demand artifacts early: Always instruct agents to create artifacts as their first deliverable. Even if it’s just a markdown plan with diagrams, it forces structured thinking and gives you something concrete to react to.

2. Comment on artifacts, don’t restart conversations: When you see something wrong in an artifact, comment directly on it (Antigravity’s artifact comment system). The agent will see your feedback in context and revise the same artifact. DON’T start a new chat with “actually, change X”—that’s a token waste.

3. Use artifact types strategically:

  • Screenshots: For UI work—instant validation

  • Recordings: For multi-step flows—see the whole process

  • Task lists: For complex implementations—track progress at a glance

  • Architecture diagrams: For system design—verify before code is written

4. Stop at “good enough” artifact: Once an artifact passes your quality threshold, approve it and move on. Don’t nitpick minor stylistic preferences—those refinement cycles add up.

Strategy 2: Skill Selection – Less Is More

Antigravity’s ecosystem boasts 300+ skills. It’s tempting to install them all and let the AI pick what it needs. But each skill adds context tokens to every task.

How Skills Burn Tokens

When Antigravity selects skills for a task, it loads each skill’s documentation, patterns, and examples into the agent’s context. A typical skill adds 2,000-8,000 tokens of reference material. Ten skills = 20k-80k tokens before your codebase even enters the context.

Multiply that by three concurrent agents, and you’ve just burned 60k-240k tokens on skill overhead alone.

The Minimalist Skill Stack

Instead of “install everything,” be ruthlessly selective:

Core skills you always need (low cost):

  • typescript-pro or python-pro (your primary language)

  • git-workflow (basic Git operations)

Domain-specific add-ons (use sparingly):

  • Only install kubernetes if you’re actually deploying to K8s this week

  • Only install security-auditor when doing a security review

  • Install testing-strategies only when writing tests, not for general tasks

Skill Caching Strategy

Antigravity caches skills globally (~/.gemini/antigravity/skills/), so the first load of a skill costs tokens, but subsequent uses in the same session are cheaper. This means:

1. Group tasks by domain: Do all your Python refactoring tasks in one session so the python-pro skill stays loaded
2. Avoid skill-hopping: Switching between backend, frontend, and DevOps tasks in rapid succession forces constant skill reloading
3. Pre-warm skills: At the start of your work session, run a simple task that activates your core skills, letting them cache before you tackle real work

The “No Skill” Surprise

For simple, straightforward tasks, don’t specify any skills. Antigravity’s base model is surprisingly capable at basic coding tasks. Adding a skill for “add input validation to this form” is overkill—it’ll do fine without one, and you save 3k-5k tokens.

Rule of thumb: Only add a skill if the task genuinely requires specialized knowledge you don’t have in your own codebase patterns.

Strategy 3: Effective Task Decomposition – Smaller Is Token-Chiper

Antigravity agents excel at focused, single-purpose tasks. Give them a sprawling “redo the entire backend” assignment, and they’ll either:

1. Pick one part and ignore the rest (wasted tokens)
2. Try to tackle everything and run out of tokens mid-task
3. Produce a shallow overview without depth

The Atomic Task Principle

Break large projects into atomic tasks that can be completed in 5,000-15,000 tokens each. Each atomic task should:

  • Have one clear deliverable (not multiple)

  • Be self-contained (minimal dependencies on unfinished work)

  • Be verifiable (you can tell at a glance if it succeeded)

Example: Atomic vs Monolithic

❌ Monolithic disaster:

"Implement the entire user management system including:
  • User registration/login with email verification

  • Password reset flow

  • Profile management

  • Role-based access control

  • Admin dashboard

  • API endpoints for all of the above

  • Unit and integration tests

  • Documentation"

This might take 100k+ tokens and likely won’t finish cleanly.

✅ Atomic approach:

Day 1: Core infrastructure

"Set up the database schema for user management with tables: users, roles, profile. Create migration files and seed data. Artifact: ER diagram + migration status screenshot."

Day 2: Authentication endpoints

"Implement POST /auth/register and POST /auth/login with JWT tokens. Include validation, error handling, and basic unit tests. Artifact: API test results showing successful registration and login."

Day 3: Email verification

"Add email verification to registration flow using [your email service]. Send verification email on registration, handle verification callback, mark user as verified. Artifact: Screenshot of received verification email + verified user in DB."

… and so on.

Each atomic task costs 8k-15k tokens, fits comfortably in the free tier, and produces clear, reviewable artifacts. The cumulative quality is often higher than one massive task because each gets focused attention.

Task Sequencing Matters

Order your atomic tasks to minimize context churn:

1. Foundation first: Schema, core models, base classes—these get reused by later tasks
2. Core features next: Main user-facing functionality builds on foundation
3. Polish last: Docs, tests, edge cases—these are cheaper once the core works

This creates positive skill reuse without extra tokens. The agent’s context from task 1 helps with task 2, but you’re not paying to re-explain everything.

The Dependencies Trap

Beware of circular dependencies between tasks. If Task B requires code from Task A that doesn’t exist yet, the agent will either:

  • Make assumptions (wrong ones)

  • Generate placeholder code you’ll have to redo

  • Do excessive “research” into your codebase (token burn)

Solution: Explicitly include necessary context in the task description:

"Task B: Implement password reset endpoint. 
Note: User model already has reset_token and reset_expires fields from Task A. 
Do not modify the schema—use those fields as they exist."

Strategy 4: Monitoring Usage – Knowledge Is Power

You can’t optimize what you don’t measure. Antigravity provides usage data, but you need to know where to look.

Built-in Usage Dashboard

Open the Manager Surface* and click the *Usage tab (bottom-left corner). You’ll see:

  • Token consumption by agent (who’s burning the most)

  • Rate limit status (requests/min, tokens/min)

  • Historical usage (last 24 hours, reset times)

  • Skill usage breakdown (which skills cost the most)

Key insight*: Look for agents that consume tokens without producing artifacts. A chatty agent that asks lots of questions but delivers little is a *token vampire. Kill those sessions and restart with tighter instructions.

Set Up Token Alerts

Don’t wait until you hit limits. Create a simple monitoring script:

~/.gemini/antigravity/monitor-tokens.sh

#!/bin/bash
Check current token usage against limits

THRESHOLD=90000  # 90k tokens/min (75% of 120k)
Antigravity CLI provides usage stats

USED=$(npx @google/antigravity-cli usage current --format json | jq '.tokensPerMinute')
if [ "$USED" -gt "$THRESHOLD" ]; then
  echo "⚠️  Token usage at $USED (threshold: $THRESHOLD)"
  # Send notification (Telegram, Discord, etc.)
  # Or automatically reduce agent count
fi

Schedule it with cron to run every 30 seconds during active work. You’ll catch runaway agents before they eat your whole minute’s allocation.

The Session-Based Budget Approach

Instead of a daily budget, think in sessions:

1. Morning session (2 hours): Budget 200k tokens, tackle the hardest tasks when fresh
2. Afternoon session (2 hours): Budget 150k tokens, handle refinements and documentation
3. Evening session (1 hour): Budget 50k tokens, quick fixes only

This prevents the “I burned all my tokens by 10 AM” problem. Track session usage in a simple log:

Token Budget Log

2026-02-25
  • Morning: 187k/200k (OAuth implementation)

  • Afternoon: 142k/150k (test coverage, docs)

  • Evening: 23k/50k (bug fix)

Over time, you’ll learn your actual consumption patterns and set realistic budgets.

Agent-Level Token Limits

Antigravity doesn’t natively support per-agent token caps, but you can manually enforce them:

  • When spawning an agent, include: "Token budget: 15,000. Stop when artifacts meet criteria or budget exhausted."

  • If an agent exceeds reasonable time without progress, manually stop it (Manager Surface has a stop button)

  • Use the “timeout” parameter in your task description: "Complete within 10 minutes or 15k tokens"

This isn’t hard enforcement, but it creates behavioral guardrails.

Strategy 5: Context Management – Send Only What’s Needed

Antigravity agents automatically search your codebase for relevant context. This is a double-edged sword.

A well-configured agent might pull in 10 files that are actually relevant. A careless one could scan your entire project (1000+ files) looking for patterns, burning thousands of tokens on irrelevant code.

Guide the Context Search

Use explicit instructions to limit scope:

Bad:

"Fix the authentication bug"

Agent searches everything auth-related → token waste.

Good:

"Fix authentication bug in src/auth/middleware.ts. 
Only examine files in src/auth/ and src/middleware/.
Do not search outside these directories."

The agent respects directory boundaries when explicitly told.

The “File Whitelist” Technique

For complex tasks, provide a curated list of files the agent should read:

"Task: Refactor payment processing in checkout flow.
Read ONLY these files:
  • src/checkout/PaymentForm.tsx

  • src/payments/stripe-client.ts

  • src/models/Order.ts

  • src/api/payment-endpoints.ts


Do not search for other payment-related files—the above are the only ones that matter for this refactor."

This turns a potentially broad search into a focused 4-file read, saving thousands of tokens.

Use .antigravityignore (If Available)

Check if Antigravity supports an ignore file (like .gitignore). Create .antigravityignore in your project root:

Exclude generated files

dist/
build/
node_modules/
Exclude test fixtures

/__fixtures__/
/test-data/
Exclude old commits' artifacts

*/.bak
*/.old

This prevents the agent from wasting tokens on files that aren’t source code.

Note: As of February 2026, .antigravityignore is experimental. Check the Antigravity docs for current support.

Strategy 6: Model Awareness – Choose Wisely

The free tier defaults to Gemini 3 Pro, but you can add Claude Sonnet 4.5 or GPT-OSS. Each has different token economics:

| Model | Input Cost (per 1M tokens) | Output Cost (per 1M tokens) | Strength |
|

Token Efficiency with Antigravity: Maximizing the Free Tier

Leave a reply

Token Efficiency with Antigravity: Maximizing the Free Tier

So you’ve discovered Google Antigravity and you’re loving the agent-first workflow. You’ve delegated your first few tasks, marveled at how agents work autonomously, and started building your skill library. But there’s one catch: the free individual tier has token limits.

“Wait, what? Token limits? I thought it was free!”

Yes, Antigravity’s public preview is free—but not unlimited. Google imposes rate limits on Gemini 3 Pro (and any additional models you connect) to ensure fair usage across millions of developers. And if you’re running multiple agents simultaneously or tackling complex projects, those tokens can vanish faster than you’d expect.

This isn’t about cutting corners—it’s about working smarter. In this post, we’ll dive deep into practical strategies that help you get the most out of Antigravity’s free tier without constantly hitting your limits. We’ll cover token budgeting, artifact optimization, skill selection, task decomposition, and usage monitoring. By the end, you’ll know exactly how to stretch your free tokens further while still getting amazing results.

Understanding Token Budgeting: The 120,000 Token Reality Check

Let’s start with the numbers. Antigravity’s free tier gives you:

  • 120,000 tokens per minute for Gemini 3 Pro (shared across all active agents)

  • 50 requests per minute (rate limit, not token-based)

  • Context window: 1M tokens per agent (but you only pay for what you use)

Here’s the thing: those 120k tokens reset every minute, but they’re a hard cap. If you spawn three agents working simultaneously, they’re all drawing from the same pool. One runaway agent can consume your entire allocation before you know it.

How Antigravity Counts Tokens

Unlike simple completion-based tools (Copilot charges per line), Antigravity tracks:

1. Input tokens: Your task description + relevant context pulled from your codebase + selected skills
2. Output tokens: Agent’s responses + generated code + artifact content
3. Tool call tokens: Each time an agent reads files, searches code, or executes commands, those operations consume tokens too

A typical “refactor this function” task might use 5,000-15,000 tokens. A complex “implement OAuth with tests and docs” could easily exceed 50,000 tokens.

The Token Budget Mindset Shift

Stop thinking in tasks. Start thinking in token units.

Instead of:
> “Let me ask Antigravity to review my PR, then fix the bugs it finds, then add tests, then update docs…”

Think:
> “I have 40,000 tokens to spend today. How can I accomplish the most valuable work within that budget?”

This mental shift changes how you approach Antigravity. You become a token allocator, not just a task delegator.

Strategy 1: Artifacts Are Your Best Friend (Reduce Back-and-Forth)

Every time you and an agent go back-and-forth—asking questions, getting clarifications, fixing misunderstandings—you’re burning tokens on context carrying. The agent has to re-read the entire conversation history each time.

Artifacts solve this by making the agent’s thinking visible and reviewable upfront.

The Artifact Advantage

When an agent produces an artifact (screenshot, test report, implementation plan), it’s a tangible deliverable you can review immediately. No need to ask “what did you do?”—the artifact shows you.

More importantly, artifacts reduce conversational turns. One thorough artifact review with inline comments replaces 3-5 chat cycles.

Example: Bad vs Good Workflow

❌ Token-Guzzling Approach:

You: "Add error handling to the API endpoints"
Agent: "Which endpoints?"
You: "All user-related ones"
Agent: "What kind of errors should I handle?"
You: "Validation errors, network timeouts, database failures"
Agent: "Should I log them?"
... 4+ more exchanges ...

≈ 15,000 tokens burned on clarification.

✅ Artifact-First Approach:

You: "Add comprehensive error handling to all user-related API endpoints. Create an artifact showing:
1. Your error handling strategy (types of errors, retry logic)
2. A diagram of the error flow
3. Screenshots of the implementation
4. Test results proving it works"

Agent produces one comprehensive artifact, you review it with comments, agent iterates once.
≈ 4,000 tokens total.

Pro Tips for Artifact Efficiency

1. Demand artifacts early: Always instruct agents to create artifacts as their first deliverable. Even if it’s just a markdown plan with diagrams, it forces structured thinking and gives you something concrete to react to.

2. Comment on artifacts, don’t restart conversations: When you see something wrong in an artifact, comment directly on it (Antigravity’s artifact comment system). The agent will see your feedback in context and revise the same artifact. DON’T start a new chat with “actually, change X”—that’s a token waste.

3. Use artifact types strategically:

  • Screenshots: For UI work—instant validation

  • Recordings: For multi-step flows—see the whole process

  • Task lists: For complex implementations—track progress at a glance

  • Architecture diagrams: For system design—verify before code is written

4. Stop at “good enough” artifact: Once an artifact passes your quality threshold, approve it and move on. Don’t nitpick minor stylistic preferences—those refinement cycles add up.

Strategy 2: Skill Selection – Less Is More

Antigravity’s ecosystem boasts 300+ skills. It’s tempting to install them all and let the AI pick what it needs. But each skill adds context tokens to every task.

How Skills Burn Tokens

When Antigravity selects skills for a task, it loads each skill’s documentation, patterns, and examples into the agent’s context. A typical skill adds 2,000-8,000 tokens of reference material. Ten skills = 20k-80k tokens before your codebase even enters the context.

Multiply that by three concurrent agents, and you’ve just burned 60k-240k tokens on skill overhead alone.

The Minimalist Skill Stack

Instead of “install everything,” be ruthlessly selective:

Core skills you always need (low cost):

  • typescript-pro or python-pro (your primary language)

  • git-workflow (basic Git operations)

Domain-specific add-ons (use sparingly):

  • Only install kubernetes if you’re actually deploying to K8s this week

  • Only install security-auditor when doing a security review

  • Install testing-strategies only when writing tests, not for general tasks

Skill Caching Strategy

Antigravity caches skills globally (~/.gemini/antigravity/skills/), so the first load of a skill costs tokens, but subsequent uses in the same session are cheaper. This means:

1. Group tasks by domain: Do all your Python refactoring tasks in one session so the python-pro skill stays loaded
2. Avoid skill-hopping: Switching between backend, frontend, and DevOps tasks in rapid succession forces constant skill reloading
3. Pre-warm skills: At the start of your work session, run a simple task that activates your core skills, letting them cache before you tackle real work

The “No Skill” Surprise

For simple, straightforward tasks, don’t specify any skills. Antigravity’s base model is surprisingly capable at basic coding tasks. Adding a skill for “add input validation to this form” is overkill—it’ll do fine without one, and you save 3k-5k tokens.

Rule of thumb: Only add a skill if the task genuinely requires specialized knowledge you don’t have in your own codebase patterns.

Strategy 3: Effective Task Decomposition – Smaller Is Token-Chiper

Antigravity agents excel at focused, single-purpose tasks. Give them a sprawling “redo the entire backend” assignment, and they’ll either:

1. Pick one part and ignore the rest (wasted tokens)
2. Try to tackle everything and run out of tokens mid-task
3. Produce a shallow overview without depth

The Atomic Task Principle

Break large projects into atomic tasks that can be completed in 5,000-15,000 tokens each. Each atomic task should:

  • Have one clear deliverable (not multiple)

  • Be self-contained (minimal dependencies on unfinished work)

  • Be verifiable (you can tell at a glance if it succeeded)

Example: Atomic vs Monolithic

❌ Monolithic disaster:

"Implement the entire user management system including:
  • User registration/login with email verification

  • Password reset flow

  • Profile management

  • Role-based access control

  • Admin dashboard

  • API endpoints for all of the above

  • Unit and integration tests

  • Documentation"

This might take 100k+ tokens and likely won’t finish cleanly.

✅ Atomic approach:

Day 1: Core infrastructure

"Set up the database schema for user management with tables: users, roles, profile. Create migration files and seed data. Artifact: ER diagram + migration status screenshot."

Day 2: Authentication endpoints

"Implement POST /auth/register and POST /auth/login with JWT tokens. Include validation, error handling, and basic unit tests. Artifact: API test results showing successful registration and login."

Day 3: Email verification

"Add email verification to registration flow using [your email service]. Send verification email on registration, handle verification callback, mark user as verified. Artifact: Screenshot of received verification email + verified user in DB."

… and so on.

Each atomic task costs 8k-15k tokens, fits comfortably in the free tier, and produces clear, reviewable artifacts. The cumulative quality is often higher than one massive task because each gets focused attention.

Task Sequencing Matters

Order your atomic tasks to minimize context churn:

1. Foundation first: Schema, core models, base classes—these get reused by later tasks
2. Core features next: Main user-facing functionality builds on foundation
3. Polish last: Docs, tests, edge cases—these are cheaper once the core works

This creates positive skill reuse without extra tokens. The agent’s context from task 1 helps with task 2, but you’re not paying to re-explain everything.

The Dependencies Trap

Beware of circular dependencies between tasks. If Task B requires code from Task A that doesn’t exist yet, the agent will either:

  • Make assumptions (wrong ones)

  • Generate placeholder code you’ll have to redo

  • Do excessive “research” into your codebase (token burn)

Solution: Explicitly include necessary context in the task description:

"Task B: Implement password reset endpoint. 
Note: User model already has reset_token and reset_expires fields from Task A. 
Do not modify the schema—use those fields as they exist."

Strategy 4: Monitoring Usage – Knowledge Is Power

You can’t optimize what you don’t measure. Antigravity provides usage data, but you need to know where to look.

Built-in Usage Dashboard

Open the Manager Surface* and click the *Usage tab (bottom-left corner). You’ll see:

  • Token consumption by agent (who’s burning the most)

  • Rate limit status (requests/min, tokens/min)

  • Historical usage (last 24 hours, reset times)

  • Skill usage breakdown (which skills cost the most)

Key insight*: Look for agents that consume tokens without producing artifacts. A chatty agent that asks lots of questions but delivers little is a *token vampire. Kill those sessions and restart with tighter instructions.

Set Up Token Alerts

Don’t wait until you hit limits. Create a simple monitoring script:

~/.gemini/antigravity/monitor-tokens.sh

#!/bin/bash
Check current token usage against limits

THRESHOLD=90000  # 90k tokens/min (75% of 120k)
Antigravity CLI provides usage stats

USED=$(npx @google/antigravity-cli usage current --format json | jq '.tokensPerMinute')
if [ "$USED" -gt "$THRESHOLD" ]; then
  echo "⚠️  Token usage at $USED (threshold: $THRESHOLD)"
  # Send notification (Telegram, Discord, etc.)
  # Or automatically reduce agent count
fi

Schedule it with cron to run every 30 seconds during active work. You’ll catch runaway agents before they eat your whole minute’s allocation.

The Session-Based Budget Approach

Instead of a daily budget, think in sessions:

1. Morning session (2 hours): Budget 200k tokens, tackle the hardest tasks when fresh
2. Afternoon session (2 hours): Budget 150k tokens, handle refinements and documentation
3. Evening session (1 hour): Budget 50k tokens, quick fixes only

This prevents the “I burned all my tokens by 10 AM” problem. Track session usage in a simple log:

Token Budget Log

2026-02-25
  • Morning: 187k/200k (OAuth implementation)

  • Afternoon: 142k/150k (test coverage, docs)

  • Evening: 23k/50k (bug fix)

Over time, you’ll learn your actual consumption patterns and set realistic budgets.

Agent-Level Token Limits

Antigravity doesn’t natively support per-agent token caps, but you can manually enforce them:

  • When spawning an agent, include: "Token budget: 15,000. Stop when artifacts meet criteria or budget exhausted."

  • If an agent exceeds reasonable time without progress, manually stop it (Manager Surface has a stop button)

  • Use the “timeout” parameter in your task description: "Complete within 10 minutes or 15k tokens"

This isn’t hard enforcement, but it creates behavioral guardrails.

Strategy 5: Context Management – Send Only What’s Needed

Antigravity agents automatically search your codebase for relevant context. This is a double-edged sword.

A well-configured agent might pull in 10 files that are actually relevant. A careless one could scan your entire project (1000+ files) looking for patterns, burning thousands of tokens on irrelevant code.

Guide the Context Search

Use explicit instructions to limit scope:

Bad:

"Fix the authentication bug"

Agent searches everything auth-related → token waste.

Good:

"Fix authentication bug in src/auth/middleware.ts. 
Only examine files in src/auth/ and src/middleware/.
Do not search outside these directories."

The agent respects directory boundaries when explicitly told.

The “File Whitelist” Technique

For complex tasks, provide a curated list of files the agent should read:

"Task: Refactor payment processing in checkout flow.
Read ONLY these files:
  • src/checkout/PaymentForm.tsx

  • src/payments/stripe-client.ts

  • src/models/Order.ts

  • src/api/payment-endpoints.ts


Do not search for other payment-related files—the above are the only ones that matter for this refactor."

This turns a potentially broad search into a focused 4-file read, saving thousands of tokens.

Use .antigravityignore (If Available)

Check if Antigravity supports an ignore file (like .gitignore). Create .antigravityignore in your project root:

Exclude generated files

dist/
build/
node_modules/
Exclude test fixtures

/__fixtures__/
/test-data/
Exclude old commits' artifacts

*/.bak
*/.old

This prevents the agent from wasting tokens on files that aren’t source code.

Note: As of February 2026, .antigravityignore is experimental. Check the Antigravity docs for current support.

Strategy 6: Model Awareness – Choose Wisely

The free tier defaults to Gemini 3 Pro, but you can add Claude Sonnet 4.5 or GPT-OSS. Each has different token economics:

| Model | Input Cost (per 1M tokens) | Output Cost (per 1M tokens) | Strength |
|