Your comprehensive handbook to building software with Google's AI-powered agentic IDE
The Antigravity Developer's Guide is the definitive technical handbook for Google Antigravity, the revolutionary AI-powered Agentic Integrated Development Environment (AIDE) from Google DeepMind. This guide is designed for software engineers, technical leads, and development teams who want to understand, adopt, and master the agent-first development paradigm.
Tagline: Stop writing code line by line. Start orchestrating AI agents to build software.
Unlike traditional IDEs where you manually write every line of code, Antigravity introduces autonomous AI agents that can plan, implement, test, and verify entire features based on high-level objectives. This handbook provides everything you need to transition from conventional development to agentic collaboration.
- The fundamental shift from "code-first" to "agent-first" development
- How to effectively delegate complex engineering tasks to AI agents
- Core architectural concepts: artifacts, task boundaries, and verification workflows
- Production-ready best practices for team adoption
- Security considerations and common pitfalls
- Real-world use cases and implementation patterns
- Introduction: What is Google Antigravity?
- Core Concepts
- Key Features
- How It Works: The Agentic Development Loop
- Supported AI Models and Integration
- Comparison with Other Tools
- Use Cases
- Benefits and Limitations
- Getting Started and Installation
- Best Practices and Tips
- Common Misconceptions
- Future Directions and What's Next
- Glossary of Terms
- References and Resources
- Repository Structure & License
Google Antigravity is an AI-native Integrated Development Environment launched by Google in November 2025. Built as a fork of Visual Studio Code, it combines the familiar interface developers know with a fundamentally new interaction model: agent-first development.
Instead of treating AI as a code completion tool or chat assistant, Antigravity positions autonomous AI agents as first-class collaborators in your development workflow. You define high-level objectives; the agent plans, implements, tests, and documents the solution.
The name symbolizes the platform's core promise: to lift developers above the "gravity" of repetitive, low-level coding tasks. Just as antigravity would free you from physical constraints, this IDE frees you from boilerplate, debugging minutiae, and manual file management—allowing you to focus on architecture, design, and strategic decisions.
| Traditional IDE | Google Antigravity |
|---|---|
| You write code manually | Agent writes code autonomously |
| AI suggests next lines | Agent implements entire features |
| Context limited to open files | Agent understands full repository |
| No built-in verification | Agent tests and validates changes |
| Chat history is ephemeral | Plans and summaries persist as artifacts |
- Software Engineers building web apps, APIs, or microservices
- Full-Stack Developers managing complex multi-file changes
- DevOps Engineers automating infrastructure and deployment scripts
- Technical Leads overseeing code quality and architecture
- Solo Developers who need to move fast without sacrificing quality
Understanding Antigravity requires grasping four foundational concepts that distinguish it from all prior development tools.
| Development Model | Interaction Pattern | Developer Role |
|---|---|---|
| Traditional | Human writes code → Computer executes | Code producer |
| Chat-First AI | Human prompts → AI suggests → Human implements | Assisted coder |
| Agent-First | Human defines goal → AI plans, codes, tests → Human reviews | Task orchestrator |
In the agent-first paradigm, you don't micro-manage implementation details. You describe what needs to be done, and the agent determines how to do it.
Traditional Approach:
1. Developer opens UserService.ts
2. Developer manually adds JWT validation logic
3. Developer updates tests
4. Developer runs tests locally
5. Developer commits changes
Agent-First Approach:
Developer: "Add JWT authentication to the UserService. Use the jsonwebtoken library."
Agent:
1. Researches existing auth patterns in the codebase
2. Creates implementation_plan.md for review
3. Upon approval, installs jsonwebtoken
4. Modifies UserService.ts with proper error handling
5. Generates unit tests
6. Runs test suite and validates
7. Creates walkthrough.md with screenshots
8. Notifies developer for final review
- 10x faster iteration on well-defined tasks
- Reduced context switching (agent handles research, testing, documentation)
- Consistent patterns across the codebase
- Built-in verification reduces bugs reaching production
An agent in Antigravity is an autonomous AI system with:
- Goals: Objectives defined by the developer
- Tools: Access to filesystem, terminal, browser, and web search
- Reasoning: Ability to plan multi-step solutions
- Memory: Persistent context via artifacts
- Verification: Self-checking mechanisms
| Tool Category | Examples | Use Cases |
|---|---|---|
| Filesystem | Read, write, edit files | Code changes, config updates |
| Terminal | Execute shell commands | Run tests, install packages, build projects |
| Browser | Navigate web pages, take screenshots | Preview UIs, validate deployments, research docs |
| Web Search | Query documentation and forums | Find API references, troubleshoot errors |
| Image Generation | Create visual assets | Generate UI mockups, diagrams |
Antigravity agents operate with supervised autonomy:
- Planning Phase: Agent proposes a plan → Human approves/rejects
- Execution Phase: Agent implements autonomously → Human can interrupt
- Verification Phase: Agent validates → Human does final review
This Human-in-the-Loop (HiTL) design ensures safety while maximizing productivity.
Task: "Debug why the login page is broken in production"
Agent Actions:
1. [Browser] Navigate to production URL
2. [Browser] Take screenshot of error
3. [Terminal] Check server logs: `kubectl logs auth-service`
4. [Web Search] Search for error message: "JWT malformed"
5. [Filesystem] Review auth middleware code
6. [Filesystem] Fix token parsing bug
7. [Terminal] Run integration tests
8. [Browser] Verify fix on staging environment
9. [Filesystem] Create walkthrough.md with before/after screenshots
Artifacts are persistent Markdown files that externalize the agent's "thought process" and work history. Unlike ephemeral chat logs, artifacts are:
- ✅ Version-controlled (committed to Git)
- ✅ Human-readable (plain Markdown)
- ✅ Reviewable (part of code review process)
- ✅ Auditable (permanent record of decisions)
| Artifact | File Name | Purpose | When Created |
|---|---|---|---|
| Task List | task.md |
Checklist of sub-tasks | Start of complex work |
| Implementation Plan | implementation_plan.md |
Technical design document | Before code changes |
| Walkthrough | walkthrough.md |
Post-completion summary | After verification |
| Knowledge Base | knowledge/*.md |
Reusable patterns and rules | Ongoing |
# Implementation Plan: Add Dark Mode Support
## Goal
Implement dark mode toggle in user settings with persistent preference storage.
## Files to Modify
- `src/components/Settings.tsx` - Add toggle UI
- `src/styles/theme.css` - Define dark mode variables
- `src/utils/localStorage.ts` - Add preference persistence
- `src/App.tsx` - Apply theme on mount
## Dependencies
- No new packages required
## Testing Strategy
1. Unit tests for localStorage utility
2. Component tests for Settings toggle
3. Visual regression tests for dark mode styles
4. Manual testing across Chrome, Firefox, Safari
## Risks
- Existing custom styles may not respect theme variables
- Third-party components may not support dark mode
## Estimated Complexity
Medium (3-4 hours)Antigravity doesn't just write code—it proves the code works.
┌─────────────────────────────────────────────────────────┐
│ VERIFICATION WORKFLOW │
├─────────────────────────────────────────────────────────┤
│ │
│ 1. Code Changes Complete │
│ ↓ │
│ 2. Run Automated Tests │
│ ├─ Unit Tests │
│ ├─ Integration Tests │
│ └─ Linting / Type Checking │
│ ↓ │
│ 3. Analyze Results │
│ ├─ All Pass? → Continue │
│ └─ Failures? → Fix and Retry │
│ ↓ │
│ 4. Manual Verification (if applicable) │
│ ├─ Launch browser │
│ ├─ Navigate to feature │
│ ├─ Take screenshots │
│ └─ Record interaction video │
│ ↓ │
│ 5. Generate Walkthrough │
│ ├─ Embed screenshots │
│ ├─ Document changes │
│ └─ List verification steps │
│ ↓ │
│ 6. Notify Developer for Review │
│ │
└─────────────────────────────────────────────────────────┘
Antigravity provides two complementary interfaces for different stages of work.
The Editor View is the familiar VS Code-style interface:
- File explorer and code editor
- Integrated terminal
- Git integration
- Agent chat panel (sidebar)
When to Use: Writing code, reviewing changes, debugging, manual testing
The Manager View is a high-level task dashboard:
- Displays
TaskName,TaskStatus,TaskSummary - Shows progress bars for multi-step tasks
- Allows parallel agent orchestration
- Provides artifact previews
When to Use: Supervising agents, managing multiple concurrent tasks, reviewing plans
| Aspect | Editor View | Manager View |
|---|---|---|
| Focus | Code and files | Tasks and progress |
| Granularity | Line-level | Feature-level |
| User Role | Hands-on developer | Project orchestrator |
| Typical Actions | Edit, debug, commit | Approve plans, monitor agents |
The core engine that powers autonomous development.
How It Works:
- You describe a high-level goal
- Agent enters PLANNING mode → creates
implementation_plan.md - You review and approve the plan
- Agent enters EXECUTION mode → implements changes
- Agent enters VERIFICATION mode → tests and validates
- Agent creates
walkthrough.md→ notifies you for review
Example:
You: "Refactor the payment processing module to use Stripe instead of PayPal"
Agent (Planning):
- Analyzes current PayPal integration
- Researches Stripe API
- Creates migration plan with rollback strategy
- Estimates 6 hours of work
You: Approve plan
Agent (Execution):
- Installs stripe npm package
- Replaces PayPal SDK calls with Stripe API
- Updates environment variables
- Migrates existing webhook handlers
Agent (Verification):
- Runs payment integration tests
- Tests webhook delivery in sandbox
- Validates error handling
- Takes screenshots of Stripe dashboard
Agent: "Migration complete. 47 tests passing. Ready for review."
All agent work is documented in version-controlled Markdown files.
Benefits:
- Transparency: See exactly what the agent planned and why
- Collaboration: Share artifacts in pull requests
- Learning: Review past decisions for similar future tasks
- Rollback: Understand changes to safely revert if needed
The agent can control a headless browser for UI validation and research.
Use Cases:
- Preview local development servers
- Take screenshots of UI components
- Validate responsive design
- Research documentation online
- Record browser interactions as videos
Example:
Task: "Implement the new checkout flow from the Figma designs"
Agent:
1. Opens Figma link in browser
2. Takes screenshots of each design state
3. Implements HTML/CSS/JS
4. Launches local server
5. Opens localhost:3000 in browser
6. Takes screenshots of implementation
7. Creates side-by-side comparison in walkthrough.md
Agents learn from past work and save reusable knowledge.
Knowledge Base Structure:
.antigravity/knowledge/
├── api_conventions.md
├── testing_standards.md
├── deployment_checklist.md
└── common_patterns.md
Example Knowledge Entry:
# API Response Format
All API endpoints must return responses in this format:
{
"success": boolean,
"data": object | null,
"error": {
"code": string,
"message": string
} | null,
"timestamp": ISO8601 string
}
Reference: Decided in PR #234The agent references these files in future tasks, ensuring consistency.
While powered primarily by Gemini 3, Antigravity supports multiple AI models:
| Model | Provider | Strengths | Use Case |
|---|---|---|---|
| Gemini 3 Pro | Best overall, 2M token context | General development | |
| Gemini 3 Deep Think | Enhanced reasoning | Complex refactoring | |
| Gemini 3 Flash | Fastest, lowest cost | Simple edits | |
| Claude Sonnet 4.5 | Anthropic | Strong instruction following | Precise implementations |
| Claude Opus 4.5 | Anthropic | Best for complex tasks | Architecture design |
┌─────────────────────────────────────────────────────────────────────┐
│ AGENTIC DEVELOPMENT LOOP │
└─────────────────────────────────────────────────────────────────────┘
1. INITIATION
Developer: "Add user authentication with email/password"
↓
2. PLANNING MODE
Agent:
- Analyzes codebase structure
- Identifies files to modify
- Researches best practices
- Creates implementation_plan.md
↓
Developer: Reviews plan → Approves or Requests Changes
↓
3. EXECUTION MODE (Loop)
Agent:
┌─────────────────────────────────────┐
│ Read relevant files │
│ ↓ │
│ Make code changes │
│ ↓ │
│ Run linters/type checkers │
│ ↓ │
│ Errors? → Fix and retry │
│ Success? → Continue │
└─────────────────────────────────────┘
↓
4. VERIFICATION MODE
Agent:
- Runs test suite (npm test, pytest, etc.)
- Analyzes test output
- If failures: return to Execution Mode
- If success: proceed to validation
- (Optional) Launch browser for UI validation
- Take screenshots/recordings
↓
5. DOCUMENTATION
Agent:
- Generates walkthrough.md
- Embeds screenshots
- Lists all modified files
- Documents verification steps
↓
6. COMPLETION
Agent: "Task complete. 23 files modified. All tests passing. Ready for review."
Developer: Reviews changes → Merges or Requests Revisions
Task: "Add a 'forgot password' feature to the login page"
Developer opens Antigravity chat panel:
"Add a forgot password link to the login page. When clicked, show a modal
where users can enter their email. Send a password reset link via SendGrid."
# Implementation Plan: Forgot Password Feature
## Scope
Add forgot password functionality with email-based reset flow.
## Files to Create
- `src/components/ForgotPasswordModal.tsx`
- `src/api/passwordReset.ts`
- `src/utils/sendgrid.ts`
## Files to Modify
- `src/pages/Login.tsx` - Add "Forgot Password?" link
- `src/App.tsx` - Add route for reset page
- `.env.example` - Add SENDGRID_API_KEY placeholder
## Dependencies to Install
- `@sendgrid/mail` (npm)
## Database Changes
- Add `password_reset_tokens` table
- Migration script: `migrations/004_password_reset.sql`
## Testing Plan
1. Unit tests for token generation
2. Integration tests for email sending (mocked)
3. E2E test for full reset flow
## Security Considerations
- Tokens expire after 1 hour
- Rate limit: 3 requests per email per hour
- Tokens are single-use
## Estimated Time
3-4 hoursDeveloper reviews and approves.
Agent actions (logged in real-time):
[Filesystem] Creating src/components/ForgotPasswordModal.tsx
[Filesystem] Creating src/api/passwordReset.ts
[Terminal] npm install @sendgrid/mail
[Filesystem] Updating src/pages/Login.tsx
[Filesystem] Creating migrations/004_password_reset.sql
[Terminal] Running linter: npm run lint
[Terminal] Running type check: npm run type-check
[Terminal] Running tests: npm test
[Output] ✓ 47 tests passed
[Browser] Launching http://localhost:3000/login
[Browser] Clicking "Forgot Password?" link
[Browser] Screenshot: forgot_password_modal.png
[Browser] Entering test email: test@example.com
[Browser] Screenshot: email_sent_confirmation.png
[Terminal] Checking SendGrid logs (sandbox mode)
[Output] ✓ Email queued successfully
# Walkthrough: Forgot Password Feature
## Changes Made
### New Files
- `src/components/ForgotPasswordModal.tsx` (87 lines)
- `src/api/passwordReset.ts` (124 lines)
- `src/utils/sendgrid.ts` (45 lines)
- `migrations/004_password_reset.sql` (18 lines)
### Modified Files
- `src/pages/Login.tsx` (+12 lines)
- `src/App.tsx` (+8 lines)
- `.env.example` (+1 line)
## Verification
### Tests
All 47 tests passing, including 5 new tests for password reset flow.
### Manual Testing
### Security Checklist
- ✅ Tokens expire after 1 hour
- ✅ Rate limiting implemented
- ✅ Tokens are single-use
- ✅ No user enumeration (same message for valid/invalid emails)
## Next Steps
1. Review code changes
2. Test in staging environment
3. Update user documentationAgent: "Forgot password feature implemented and verified.
Ready for your review."
Developer: Reviews code → Approves → Merges to main branch
Google Antigravity is powered by the Gemini 3 series from Google DeepMind.
| Model | Context Window | Strengths | Best For |
|---|---|---|---|
| Gemini 3 Pro | 2M tokens | Best balance of quality, speed, cost | General development tasks |
| Gemini 3 Deep Think | 2M tokens | Enhanced multi-step reasoning | Complex refactoring, architecture |
| Gemini 3 Flash | 1M tokens | Fastest response time | Quick edits, autocomplete |
Antigravity supports connecting to third-party models for specific use cases:
| Model | Use Case |
|---|---|
| Claude Sonnet 4.5 | Precise implementations, strong safety |
| Claude Opus 4.5 | Complex problem-solving, detailed analysis |
| Model | Use Case |
|---|---|
| GPT-OSS-120B | Data residency requirements, custom fine-tuning |
# Pseudo-code: Intelligent model routing
def select_model(task_type, complexity, budget):
if task_type == "autocomplete":
return "gemini-3-flash"
elif task_type == "refactoring" and complexity == "high":
return "gemini-3-deep-think"
elif budget == "low":
return "gemini-3-flash"
else:
return "gemini-3-pro" # Default{
"models": {
"primary": "gemini-3-pro",
"fallback": "gemini-3-flash",
"specialized": {
"refactoring": "gemini-3-deep-think",
"security_review": "claude-sonnet-4.5"
}
},
"rate_limits": {
"requests_per_minute": 60,
"tokens_per_day": 1000000
}
}| Feature | Antigravity | GitHub Copilot | Cursor | Aider | Windsurf |
|---|---|---|---|---|---|
| Type | AI-Native AIDE | IDE Extension | AI-Native IDE | CLI Tool | AI-Native IDE |
| Primary Paradigm | ⭐ Agent-First | Assist-First | Hybrid | Agentic CLI | Agent-First |
| Autonomy Level | ⭐ High (Task-level) | Low (Line-level) | Medium | Medium | High |
| Context Scope | ⭐ Full Repository | Open files | Full codebase | Git repository | Full project |
| Planning Artifacts | ⭐ Explicit (MD files) | None | Implicit | Git commits | Implicit |
| Tool Access | ⭐ Terminal + Browser + Web | Limited | Terminal | Terminal | Terminal |
| Verification | ⭐ Built-in (Tests + Screenshots) | Manual | Manual | Can run tests | Auto-fix loops |
| Multi-Model Support | ✅ Gemini, Claude, GPT-OSS | ❌ OpenAI only | ✅ GPT, Claude | ✅ Flexible | |
| Pricing | Free (Preview) | $10-20/month | Free + Paid tiers | Free (Open-source) | Free + Paid tiers |
Copilot Strengths:
- Excellent autocomplete for common patterns
- Seamless integration with existing workflows
- Large user base and community
Antigravity Advantages:
- Handles multi-file, cross-cutting changes
- Autonomous testing and verification
- Explicit planning phase reduces errors
- Full repository understanding
When to Use Copilot: Quick coding sessions, pair programming, learning new APIs
When to Use Antigravity: Feature implementation, refactoring, debugging complex issues
Cursor Strengths:
- AI-first IDE with strong codebase understanding
- Familiar VS Code interface
- Good multi-file editing
Antigravity Advantages:
- Formal artifact system (plans, walkthroughs)
- Integrated browser for UI validation
- Native verification workflows
- Stronger autonomy (task-level vs file-level)
When to Use Cursor: Teams wanting AI-first IDE without full agent autonomy
When to Use Antigravity: Teams ready to delegate entire features to agents
Aider Strengths:
- Open-source and free
- Deep Git integration
- CLI-native workflow
- Model flexibility
Antigravity Advantages:
- Full IDE experience (not just CLI)
- Browser tooling for UI work
- Visual artifact system
- Enterprise support
When to Use Aider: CLI-first developers, open-source projects, budget constraints
When to Use Antigravity: Teams needing full IDE + agent capabilities
Scenario: "Build a user dashboard with activity feed, profile settings, and analytics charts"
Antigravity Workflow:
- Agent creates implementation plan with component breakdown
- Scaffolds React components with TypeScript
- Implements API integration
- Adds Chart.js for analytics visualization
- Writes unit and integration tests
- Launches browser, takes screenshots of each section
- Creates walkthrough with visual proof
Time Saved: 8-10 hours → 2-3 hours (including review)
Scenario: "Migrate this Express.js app from JavaScript to TypeScript"
Antigravity Workflow:
- Agent analyzes entire codebase structure
- Creates migration plan with file-by-file strategy
- Converts files incrementally
- Adds type definitions
- Fixes type errors iteratively
- Runs test suite after each batch
- Documents breaking changes
Time Saved: 20-30 hours → 4-6 hours
Scenario: "Users report checkout failing intermittently"
Antigravity Workflow:
- Agent reviews error logs
- Searches codebase for payment processing logic
- Identifies race condition in async flow
- Proposes fix with proper error handling
- Adds regression test
- Verifies fix in staging environment
- Documents root cause analysis
Time Saved: 4-6 hours → 1-2 hours
Scenario: "Generate comprehensive API documentation for all endpoints"
Antigravity Workflow:
- Agent scans all route definitions
- Extracts request/response schemas
- Generates OpenAPI/Swagger spec
- Creates markdown documentation
- Adds code examples for each endpoint
- Generates Postman collection
Time Saved: 10-15 hours → 1 hour
Scenario: "Add unit tests for the entire authentication module"
Antigravity Workflow:
- Agent analyzes auth module functions
- Identifies edge cases and error paths
- Generates test cases with mocks
- Achieves 90%+ code coverage
- Runs tests and fixes failures
- Documents test strategy
Time Saved: 6-8 hours → 1-2 hours
Scenario: "Review codebase for common security vulnerabilities"
Antigravity Workflow:
- Agent scans for SQL injection risks
- Checks for XSS vulnerabilities
- Reviews authentication/authorization logic
- Identifies hardcoded secrets
- Generates security report with CVE references
- Proposes fixes for each issue
Time Saved: 8-12 hours → 2-3 hours
Quantified Impact:
- Routine tasks: 5-10x faster (e.g., CRUD operations, boilerplate)
- Complex refactoring: 3-5x faster
- Documentation: 10x faster
- Testing: 5x faster
Developers spend 23% of their time searching for information (Stack Overflow, docs, GitHub issues). Antigravity's agent handles this research autonomously.
Before: Code → Google → Read docs → Return to code → Repeat After: Describe goal → Agent researches and implements
Agents follow established patterns from the knowledge base, ensuring:
- Uniform coding style
- Consistent error handling
- Standard testing practices
- Proper documentation
New team members can contribute faster:
- Agent explains existing code
- Suggests best practices
- Handles unfamiliar tech stacks
- Provides guided implementation
Every change is tested and validated:
- Automated test execution
- Visual UI verification
- Performance checks
- Security scans
Artifacts create an institutional memory:
- Design decisions are documented
- Implementation rationale is preserved
- Future developers understand "why" not just "what"
Challenge: The agent-first mental model is new.
Mitigation:
- Start with small, well-defined tasks
- Review implementation plans carefully
- Gradually increase task complexity
Challenge: Autonomous loops take time (minutes, not seconds).
Reality Check:
- Simple tasks: 1-3 minutes
- Medium tasks: 5-15 minutes
- Complex tasks: 30-60 minutes
Mitigation: Use for tasks that would take hours manually. For quick edits, traditional coding may be faster.
Challenge: Agents can make mistakes.
Critical Rule: Always review implementation plans and final code. Blind approval is dangerous.
Best Practice: Treat the agent like a smart junior developer—capable but requiring oversight.
Challenge: Running multiple agents with large context windows is computationally intensive.
Considerations:
- API costs (though free tier is generous during preview)
- Local compute for self-hosted models
- Network bandwidth for cloud models
Challenge: Novel, unprecedented problems may stump the agent.
Reality: Agents excel at patterns they've seen before. Truly unique challenges still require human creativity.
Mitigation: Break down novel problems into familiar sub-problems.
Challenge: Agents have broad access to your codebase and can execute commands.
Mitigation:
- Review all terminal commands before execution
- Use
.antigravityignorefor sensitive files - Audit agent actions regularly
- Implement access controls in team settings
| Component | Requirement |
|---|---|
| Operating System | Windows 10+, macOS 11+, Linux (Ubuntu 20.04+) |
| RAM | 8 GB minimum, 16 GB recommended |
| Storage | 500 MB for IDE + project space |
| Internet | Required for cloud models (optional for self-hosted) |
# Download installer
Invoke-WebRequest -Uri https://antigravity.google/download/windows -OutFile antigravity-setup.exe
# Run installer
.\antigravity-setup.exe# Download DMG
curl -O https://antigravity.google/download/macos/antigravity.dmg
# Mount and install
hdiutil attach antigravity.dmg
cp -R /Volumes/Antigravity/Antigravity.app /Applications/# Add repository
wget -qO- https://antigravity.google/linux/key.gpg | sudo apt-key add -
echo "deb https://antigravity.google/linux/deb stable main" | sudo tee /etc/apt/sources.list.d/antigravity.list
# Install
sudo apt update
sudo apt install antigravity-
Open Antigravity from your applications menu
-
Sign in with Google Account
- Required for Gemini model access
- Free tier during public preview
-
Choose a Workspace
File → Open Folder → Select your project directory -
Initialize Agent
- Press
Ctrl+Shift+P(Windows/Linux) orCmd+Shift+P(macOS) - Type "Antigravity: Open Chat"
- Agent panel appears in sidebar
- Press
-
Your First Task
Try: "Explain the structure of this project" Agent will analyze your codebase and provide an overview.
// .antigravity/settings.json
{
"agent": {
"defaultModel": "gemini-3-pro",
"temperature": 0.2,
"maxTokens": 4096
},
"verification": {
"autoRunTests": true,
"requireScreenshots": false
},
"artifacts": {
"location": ".antigravity/brain",
"autoCommit": false
}
}// .antigravity/project.json
{
"name": "my-web-app",
"language": "typescript",
"framework": "react",
"testCommand": "npm test",
"buildCommand": "npm run build",
"devServer": "npm run dev"
}| Action | Windows/Linux | macOS |
|---|---|---|
| Open Agent Chat | Ctrl+Shift+A |
Cmd+Shift+A |
| Approve Plan | Ctrl+Enter |
Cmd+Enter |
| Interrupt Agent | Ctrl+C |
Cmd+C |
| View Artifacts | Ctrl+Shift+B |
Cmd+Shift+B |
| Switch to Manager View | Ctrl+Shift+M |
Cmd+Shift+M |
"Fix the bug"
"Fix the NullPointerException in UserService.java line 127 that occurs when
a user with no profile picture tries to log in. Add proper null checking and
a default avatar fallback."
- What needs to be done
- Where in the codebase
- Why it's needed (context)
- Constraints (performance, compatibility, etc.)
- Success criteria (how to verify)
Critical Checkpoint: The implementation plan is your last chance to catch issues before code changes.
Review Checklist:
- Are all necessary files identified?
- Are dependencies reasonable?
- Is the testing strategy sufficient?
- Are security considerations addressed?
- Is the estimated time realistic?
- Are there any missing edge cases?
If unsure: Ask the agent to revise the plan with more details.
Don't expect perfection on the first try. Iterate:
You: "Add a user profile page"
Agent: [Creates implementation]
You: "The layout looks good, but move the edit button to the top right,
and add a confirmation dialog before saving changes."
Agent: [Refines implementation]
Instead of:
"Build a complete e-commerce platform"
Do this:
1. "Create the product catalog page with grid layout"
2. "Implement product detail page with image gallery"
3. "Add shopping cart functionality"
4. "Implement checkout flow with Stripe integration"
5. "Add order history page"
Each task is manageable and verifiable independently.
Create reusable guidelines in .antigravity/knowledge/:
# API Error Handling Standard
All API routes must use this error handling pattern:
try {
// Route logic
} catch (error) {
logger.error('Route error:', error);
if (error instanceof ValidationError) {
return res.status(400).json({ error: error.message });
}
if (error instanceof AuthError) {
return res.status(401).json({ error: 'Unauthorized' });
}
return res.status(500).json({ error: 'Internal server error' });
}The agent will reference this in future API implementations.
- Review all terminal commands before execution
- Use
.antigravityignorefor sensitive files:.env .env.local secrets/ *.key *.pem - Audit agent actions regularly via artifacts
- Limit agent permissions in team settings
- Never commit API keys to artifacts
- Use Gemini 3 Flash for simple tasks
- Cache common queries (agent does this automatically)
- Compress prompts by removing verbose descriptions
- Batch similar tasks to reuse context
- Monitor usage in the dashboard
Let the agent write tests first:
You: "Before implementing the feature, write comprehensive tests for the
user authentication flow. Include happy path, error cases, and edge cases."
Agent: [Writes tests]
You: [Review tests]
You: "Now implement the feature to make these tests pass."
Agent: [Implements feature using TDD approach]
Reality: Autocomplete suggests the next few characters. Antigravity plans and implements entire features across multiple files.
Reality: Antigravity is a force multiplier, not a replacement. It handles implementation; you handle strategy, architecture, and review.
Analogy: It's like having a smart junior developer who needs supervision but dramatically increases your output.
Reality: Human review is critical. Agents make mistakes. Always review plans and code.
Reality: The agent has full terminal access (with permission) and can run builds, tests, and any CLI command.
Reality: The agent has a large context window but benefits from explicit guidance. Build a knowledge base for project-specific patterns.
Reality: Antigravity excels at complex, multi-step tasks like refactoring, migration, and feature implementation.
Reality: You describe tasks in natural language. No new syntax to learn.
Reality: For well-defined tasks, it's 5-10x faster. For exploratory work, manual coding may be quicker.
Google has outlined an ambitious roadmap for Antigravity's evolution:
Vision: Deploy specialized agents that collaborate on complex projects.
Example:
- Frontend Agent: Handles React components and styling
- Backend Agent: Manages API endpoints and database
- DevOps Agent: Handles deployment and infrastructure
- QA Agent: Writes and runs tests
These agents coordinate autonomously, with human oversight at key decision points.
Vision: One-click deployment to Google Cloud Platform.
Features:
- Deploy to Cloud Run directly from IDE
- Provision Cloud SQL databases
- Set up Cloud Functions
- Configure load balancers and CDN
Example:
You: "Deploy this app to Cloud Run with auto-scaling"
Agent:
1. Builds Docker container
2. Pushes to Google Container Registry
3. Creates Cloud Run service
4. Configures environment variables
5. Sets up custom domain
6. Provides deployment URL
Vision: Agents that proactively maintain code health.
Features:
- Nightly dependency vulnerability scans
- Automatic security patch application
- Performance regression detection
- Code quality monitoring
Example:
Agent (Nightly Report):
"Detected 3 vulnerabilities in dependencies:
- lodash: CVE-2024-1234 (High) → Upgraded to 4.17.22
- axios: CVE-2024-5678 (Medium) → Upgraded to 1.6.2
- express: CVE-2024-9012 (Low) → Upgrade available
All tests passing after updates. PR created for review."
Vision: Multiple developers and agents working simultaneously.
Features:
- Live agent activity visibility
- Conflict-free concurrent editing
- Shared agent context
- Team knowledge base
Example: "Google Docs for Code" where agents and humans collaborate in real-time.
Vision: Fine-tune Gemini models on your private codebase.
Benefits:
- Better understanding of proprietary frameworks
- Adherence to company-specific patterns
- Improved accuracy for domain-specific tasks
Planned Integrations:
- Jira/Linear for automatic task tracking
- Slack/Discord for agent notifications
- GitHub/GitLab for PR automation
- Datadog/New Relic for monitoring integration
| Term | Definition |
|---|---|
| AIDE | Agentic Integrated Development Environment. A new category of IDE where AI agents are first-class citizens. |
| Agent | An autonomous AI system with access to tools (filesystem, terminal, browser) that can plan and execute complex tasks. |
| Agent-First Paradigm | A development model where AI agents handle implementation while humans focus on orchestration and review. |
| Agentic Mode | The state where the agent is actively looping through its tools to solve a user-defined task. |
| Artifact | A persistent Markdown file created by the agent to store plans, summaries, or knowledge. |
| Editor View | The traditional code editing interface with file explorer, terminal, and editor. |
| Ephemeral Message | A system message visible only to the agent (not the user), used for internal state management. |
| HiTL (Human-in-the-Loop) | A design pattern where critical agent actions require explicit human approval. |
| Implementation Plan | An artifact (implementation_plan.md) outlining proposed technical changes before execution. |
| Knowledge Base | A collection of reusable patterns, conventions, and rules stored in .antigravity/knowledge/. |
| Manager View | A high-level dashboard for supervising agents and their progress. |
| Task Boundary | A marker indicating the start, update, or end of a distinct unit of work. |
| Verification Workflow | The process by which the agent tests and validates its changes (running tests, taking screenshots, etc.). |
| Walkthrough | An artifact (walkthrough.md) summarizing completed work, often with embedded screenshots or recordings. |
- Google Antigravity Official Site: https://antigravity.google/
- Documentation: https://antigravityide.help/
- Blog Announcement: https://blog.google/technology/google-labs/antigravity-ide-launch/
- Community Forum: https://community.antigravity.google/
- Google DeepMind: https://deepmind.google/
- Gemini Models: https://deepmind.google/technologies/gemini/
- Gemini API: https://ai.google.dev/
- Google Cloud AI: https://cloud.google.com/ai
- "Agentic AI Systems: Principles and Practices" (Google DeepMind, 2025)
- "From Code Completion to Code Generation: The Evolution of AI-Assisted Development" (Google Research, 2025)
- The New Stack: "Google Antigravity: A Deep Dive into Agentic Development"
- TechCrunch: "How Google's Antigravity is Changing Software Development"
- Hacker News: Active discussions on Antigravity adoption
- Reddit: r/Antigravity
- Discord: Antigravity Developers Community
- YouTube: Antigravity Official Channel (tutorials and demos)
- GitHub: Antigravity Examples Repository
- "AI Coding Assistants in 2025: A Comprehensive Comparison"
- "Cursor vs Antigravity: Which Agent-First IDE is Right for You?"
- "The State of AI-Assisted Development: 2025 Survey Results"
my-project/
├── .antigravity/ # Antigravity configuration and artifacts
│ ├── settings.json # User preferences
│ ├── project.json # Project configuration
│ ├── brain/ # Agent memory and state
│ │ ├── task.md # Current task checklist
│ │ ├── implementation_plan.md # Active plan
│ │ └── walkthrough.md # Completion summaries
│ └── knowledge/ # Reusable patterns and rules
│ ├── api_conventions.md
│ ├── testing_standards.md
│ └── deployment_checklist.md
├── src/ # Source code
├── tests/ # Test suites
├── docs/ # Documentation
│ └── ANTIGRAVITY_GUIDE.md # This handbook
├── .antigravityignore # Files to exclude from agent access
├── .gitignore
├── package.json # Or equivalent (requirements.txt, go.mod, etc.)
└── README.md
# Sensitive files
.env
.env.local
.env.production
secrets/
*.key
*.pem
# Large files
node_modules/
dist/
build/
*.log
# Personal files
.vscode/
.idea/
Recommendation: Commit artifacts to version control.
Benefits:
- Permanent record of design decisions
- Reviewable in pull requests
- Helps onboard new team members
- Enables rollback with context
Exception: Exclude sensitive or temporary artifacts via .gitignore.
This handbook is released under the MIT License.
MIT License
Copyright (c) 2025 The Antigravity Developer's Guide Contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
🚀 Welcome to the Future of Software Development 🚀
Stop writing code line by line. Start orchestrating AI agents to build software.