The IDE & Agent Manager

Antigravity ships two distinct surfaces inside the same application: the editor view and the agent manager. The editor is where you write code, see diffs, and interact with files directly. The agent manager is where agents live -- it is the command center for spawning, monitoring, and directing agents that work across editor, terminal, and browser. Understanding both surfaces, and when to use each, is the difference between treating Antigravity as a fancy autocomplete and using it as an agentic platform.

What you'll learn

• The editor is a VS Code fork with AI-powered tab completions, inline commands, and context-aware suggestions
• The agent manager is a dedicated surface for orchestrating multiple agents working in parallel
• Agents operate autonomously across editor, terminal, and browser -- you review, not drive
• Subagents can be spawned programmatically by the main agent for parallel work with workspace isolation

The problem

Most AI coding tools bolt a chat sidebar onto an existing editor. This works for asking questions about code and generating single-file edits but creates friction for multi-step, multi-file tasks. You have to manually copy the suggestion into the right file, run the right terminal command, check the output, and feed it back to the chat. The chat is a consultant. You are still doing all the integration work.

Antigravity's agent manager inverts this. The agent is the one doing the integration work. It reads files, edits them, runs terminal commands, reads the output, and decides what to do next. Your job is to review the plan at the start and the results at the end.

Options & when to use each

Approach	What it is	When to use it
Editor view (hands-on)	Type code directly with AI completions and inline commands. You control every change	Small, targeted edits where you know exactly what you want; learning a codebase
Agent manager (delegation)	Hand a task to an agent. It plans, executes across surfaces, and reports back	Multi-file features, refactors, bug fixes, anything that spans more than one file
Parallel agents	Spawn multiple agents simultaneously on different tasks or the same task in different workspaces	Large features that can be split; independent sub-tasks (tests + implementation + docs)
Subagents (automatic)	The main agent spawns subagents programmatically for parallel subtasks	Agent decides the work is parallelizable; you do not need to manually split

Build it: your first delegated task

Open Antigravity and start a new conversation (standalone, without a project, for this exercise). This opens the agent manager view.

1. In the agent input, describe the task at the objective level:
   "Add a .gitignore file appropriate for this project's language. 
    Check what language and framework is in use and add sensible ignores."

2. Watch the agent produce a plan. It will:
   - Read project files to determine the language and framework
   - Propose a .gitignore content in an Artifact
   - Wait for your approval

3. Review the plan. If it looks correct, approve it.

4. The agent writes the file, then reports completion.

The key difference from a sidebar chat: you gave the agent an objective, not a series of commands. It decided which files to read, how to determine the project type, what to put in the .gitignore, and how to report back.

Reading the agent manager

The agent manager is organized around conversations. Each conversation is a session with an agent (or agents). The left side panel shows:

• Projects -- grouped collections of conversations with shared settings and permissions
• Standalone conversations -- one-off sessions that do not belong to a project
• Status indicators -- running, waiting for input, or completed

Inside a conversation, you see the agent's thought process: what it plans to do, what it is doing, what Artifacts it produces (plans, diffs, screenshots, logs), and what it reports at the end. You can leave feedback on any Artifact to steer the agent mid-task.

Parallel agents in practice

The agent manager supports multiple simultaneous agents. Here is a common pattern:

# Agent 1: Implementation
# Prompt: "Implement the /api/users endpoint with input validation"

# Agent 2: Tests
# Prompt: "Write integration tests for the /api/users endpoint 
#          covering happy path, missing fields, and invalid data"

# Agent 3: Documentation
# Prompt: "Update the API documentation to include the /api/users endpoint"

These three agents run concurrently. Agent 2 can start writing tests as soon as Agent 1 has a draft. If Agent 2's tests fail against Agent 1's code, you catch the mismatch while both conversations are still active, not after one is "done."

What goes wrong

Mistake	How you notice it	The fix
Micromanaging the agent	You give step-by-step instructions (read this file, then change this line, then run this test)	Give objectives, not commands. The agent handles the steps. If it gets a step wrong, leave feedback on the Artifact
Approving a plan without reading it	Agent makes architectural choices you disagree with	The plan Artifact is your review point. If the approach is wrong, reject the plan and describe the approach you want
Spawning too many parallel agents on the same files	Merge conflicts or agents overwriting each other's work	Use Git worktrees. Antigravity 2.0 supports native worktree creation -- check "New Worktree" when starting a conversation
Ignoring the agent's status	Agent is waiting for input (approval, feedback, or a decision) and you walk away	The agent manager shows clearly when an agent is blocked on you. Check status indicators before stepping away

Confirm it worked

Run two parallel agents on the same codebase:

1. Agent A: "Write a README.md for this project. Read the codebase first to understand what it does."
2. Agent B: "Run the test suite and report which tests fail, if any."

Both agents should complete independently. In the agent manager sidebar, you should see two active conversations running simultaneously. When they finish, you will have a README.md and a test report produced concurrently, not sequentially.

If both complete without blocking each other, you have successfully used parallel agents.

Next: Projects & Conversations