Using Agents

Antigravity Kit provides 20 specialist AI agents that automatically apply expert knowledge to your requests. You don’t need to memorize agent names or explicitly mention them - the system intelligently detects the right specialist for your task.

Automatic Agent Selection

The most powerful feature of Antigravity Kit is automatic agent detection. Simply describe what you need in natural language, and the system will:

Analyze your request silently
Detect the domain(s) automatically (frontend, backend, security, etc.)
Select the best specialist(s)
Inform you which expertise is being applied
Deliver specialist-level responses

You get expert responses without needing to know the system architecture!

Real-World Examples

Here’s how automatic agent selection works in practice:

You: "Add JWT authentication"
AI: 🤖 Applying @security-auditor + @backend-specialist...

The system recognizes this requires both security expertise and backend development knowledge.

You: "Fix the dark mode button"
AI: 🤖 Using @frontend-specialist...

UI issues automatically route to the frontend specialist.

You: "Login returns 500 error"
AI: 🤖 Using @debugger for systematic analysis...

Error diagnosis triggers the debugging specialist.

Benefits of Automatic Selection

Zero Learning Curve

Just describe what you need in plain language. No need to learn agent names or when to use them.

Always Expert Responses

Every response comes from specialist-level knowledge, ensuring best practices and optimal solutions.

Transparent Process

The system always shows which agent is being applied, so you understand the expertise being used.

Override Capability

You can still explicitly mention agents if you want specific expertise applied.

Explicit Agent Mention

While automatic selection works for most cases, you can explicitly mention an agent using the @agent-name syntax:

You: "@security-auditor review this authentication code"

This forces the use of the security auditor agent, even if the system would have chosen differently.

When to Use Explicit Mentions

Second Opinion: Get a specific agent’s perspective on a solution
Specialized Review: Request a particular expertise for code review
Override Behavior: Force a specific agent when automatic selection isn’t optimal

Explicit agent mentions are useful for code reviews or when you want a specific perspective on a problem.

Agent Specializations

Here’s a quick reference of available agents and their focus areas:

Frontend & UI

@frontend-specialist - Web UI/UX, React, Next.js
@mobile-developer - iOS, Android, React Native
@game-developer - Game logic, mechanics

Backend & Data

@backend-specialist - API, business logic, Node.js
@database-architect - Schema design, SQL, Prisma

Quality & Security

@security-auditor - Security compliance, OWASP
@penetration-tester - Offensive security testing
@test-engineer - Testing strategies, E2E tests
@qa-automation-engineer - Automated testing, CI pipelines

DevOps & Infrastructure

@devops-engineer - CI/CD, Docker, deployment
@performance-optimizer - Speed optimization, Web Vitals

Planning & Analysis

@project-planner - Discovery, task planning
@product-manager - Requirements, user stories
@product-owner - Strategy, backlog, MVP
@orchestrator - Multi-agent coordination

Specialized Tasks

@debugger - Root cause analysis
@seo-specialist - SEO, ranking, visibility
@documentation-writer - Technical documentation
@code-archaeologist - Legacy code refactoring
@explorer-agent - Codebase analysis

Multi-Agent Orchestration

For complex full-stack tasks, multiple agents work together seamlessly. The @orchestrator agent coordinates specialist agents to handle different aspects of your project.

Example: Building a Full-Stack E-Commerce App

You: "/orchestrate Build a full-stack e-commerce app"

The orchestrator breaks down the task and coordinates multiple specialists:

┌─────────────────────────────────────────────────────────────┐
│                     ORCHESTRATOR AGENT                       │
│  Decomposes task into sequential workstreams                │
└─────────────────────────────────────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        │                     │                     │
        ▼                     ▼                     ▼
┌───────────────┐   ┌───────────────┐   ┌───────────────┐
│ FRONTEND      │   │ BACKEND       │   │ DATABASE      │
│ SPECIALIST    │   │ SPECIALIST    │   │ ARCHITECT     │
│               │   │               │   │               │
│ Builds:       │   │ Builds:       │   │ Builds:       │
│ • UI/UX       │   │ • REST API    │   │ • Schema      │
│ • Components  │   │ • Auth        │   │ • Migrations  │
│ • Pages       │   │ • Business    │   │ • Indexes     │
└───────┬───────┘   └───────┬───────┘   └───────┬───────┘
        │                   │                   │
        └─────────────────┬─┴───────────────────┘
                          │
                          ▼
        ┌─────────────────────────────────────┐
        │      CODE COHERENCE                 │
        │  • Maintains consistency            │
        │  • Sequential context switching     │
        │  • Ensures API contracts match      │
        └──────────────┬──────────────────────┘
                       │
                       ▼
        ┌─────────────────────────────────────┐
        │    VALIDATION (All Agents)          │
        │  • test-engineer → Tests            │
        │  • security-auditor → Security      │
        │  • performance-optimizer → Perf     │
        └──────────────┬──────────────────────┘
                       │
                       ▼
        ┌─────────────────────────────────────┐
        │    DEPLOYMENT                       │
        │  • devops-engineer → Deploy         │
        └─────────────────────────────────────┘

The AI processes each domain sequentially, switching context between specialist “personas.” This is simulated multi-agent behavior, not true parallel execution, but it maintains consistency across all code generated.

How Code Coherence is Maintained

When multiple agents work on a project, the system ensures:

Consistent imports and paths - All modules reference each other correctly
Type safety - TypeScript types match across frontend and backend
API contracts - Frontend calls match backend endpoints exactly
Coding style - Consistent patterns and conventions throughout

Validation After Multi-Agent Work

After multiple agents complete their work, the system runs comprehensive validation:

# Quick validation during development
python .agent/scripts/checklist.py .

# Full verification before deployment
python .agent/scripts/verify_all.py . --url http://localhost:3000

Validation includes:

Security scan (no vulnerabilities)
Code quality (ESLint, TypeScript)
Test suite passes
E2E tests pass
Accessibility compliance (WCAG AA)
Performance audit (Lighthouse > 90)

Request Routing Examples

Here’s how different types of requests are automatically routed to the right agents:

Your Request	Detected Domain	Agent(s) Applied
”Add a contact form”	Frontend	@frontend-specialist
”Create a REST API for users”	Backend	@backend-specialist
”Design user database schema”	Database	@database-architect
”Deploy to AWS”	DevOps	@devops-engineer
”Fix security vulnerability”	Security	@security-auditor
”Login returns 500 error”	Debugging	@debugger
”Build authentication system”	Full-stack	@orchestrator → multiple agents
”Optimize page load speed”	Performance	@performance-optimizer
”Improve SEO”	Marketing	@seo-specialist

For full-stack features or complex tasks involving multiple domains, the system automatically uses the orchestrator to coordinate multiple specialist agents.

Next Steps

Learn about Slash Commands for structured workflows
Read Best Practices for optimal results
See the Web App Example for a complete walkthrough

Get Started

CLI Commands

Core Concepts

Usage Guide

Using Agents

Using Agents

Automatic Agent Selection

Real-World Examples

Benefits of Automatic Selection

Zero Learning Curve

Always Expert Responses

Transparent Process

Override Capability

Explicit Agent Mention

When to Use Explicit Mentions

Agent Specializations

Multi-Agent Orchestration

Example: Building a Full-Stack E-Commerce App

How Code Coherence is Maintained

Validation After Multi-Agent Work

Request Routing Examples

Next Steps

Build docs developers (and LLMs) love

Get Started

CLI Commands

Core Concepts

Usage Guide

​Using Agents

​Automatic Agent Selection

​Real-World Examples

​Benefits of Automatic Selection

Zero Learning Curve

Always Expert Responses

Transparent Process

Override Capability

​Explicit Agent Mention

​When to Use Explicit Mentions

​Agent Specializations

​Multi-Agent Orchestration

​Example: Building a Full-Stack E-Commerce App

​How Code Coherence is Maintained

​Validation After Multi-Agent Work

​Request Routing Examples

​Next Steps

Build docs developers (and LLMs) love

Using Agents

Automatic Agent Selection

Real-World Examples

Benefits of Automatic Selection

Explicit Agent Mention

When to Use Explicit Mentions

Agent Specializations

Multi-Agent Orchestration

Example: Building a Full-Stack E-Commerce App

How Code Coherence is Maintained

Validation After Multi-Agent Work

Request Routing Examples

Next Steps