Antigravity Agent Says 'Done' But Nothing Changed: 5 Causes and How to Fix Them

The agent says it's done. The chat shows a diff. You open the file and… nothing changed.

This is one of the most disorienting problems new Antigravity users run into. No error message, no red text — the agent genuinely believes it succeeded. But the code is untouched. Repeating the same prompt doesn't help, and without knowing where to look, it's easy to waste 30 minutes chasing a ghost.

This happens because Antigravity's agent works through a sequence of steps — planning, file lookup, writing, verification — and failure at any single step can produce the exact same symptom: a chat that looks successful but a file that hasn't changed. The fix for each cause is different, so the first task is always diagnosis.

Here are the five most common reasons this happens, plus a structured diagnostic flow that resolves the issue in under five minutes.

Pattern 1: The Agent Planned But Never Executed

This is the most frequent culprit. When Antigravity is in Planning Mode, the agent proposes changes in the chat — including a diff preview — but does not write anything to disk. What you see in the chat is a proposal, not a commit. The agent considers its job done once it has described the changes; applying them is a separate action.

How to check: Look at the mode indicator in the top-right corner of the Antigravity window. If it reads "Plan," this is your answer.

Fix: Switch to Fast Mode, or explicitly ask the agent to execute:

// ❌ In Planning Mode — nothing gets written to disk
You: "Add error handling to fetchUser"
Agent: "Here's my plan: I'll add a try-catch block around the fetch call..."

// ✅ Explicitly request execution
You: "Add error handling to fetchUser and apply the changes now"
Agent: [edits the file directly]

For everyday small edits, set Fast Mode as your default under Settings → Agent → Default Mode. Reserve Planning Mode for large, multi-file changes where you want to review the approach before committing to it.

Pattern 2: File Path Mismatch

The agent wrote the correct code — just to the wrong location. This is especially common in monorepos or deeply nested directory trees, where similarly named files exist in multiple places.

The agent targets src/utils/auth.ts, but the real file lives at apps/web/src/utils/auth.ts. If the target path doesn't exist, the write fails silently. If a different file happens to match the path, that one gets modified instead — which is even more confusing.

How to check: Open the Actions panel (right sidebar) and inspect the file path in the most recent write operation. You can also verify from the terminal without relying on your editor:

# Find .ts files modified in the last 5 minutes
find . -name "*.ts" -newer package.json -not -path "*/node_modules/*" 2>/dev/null

If the file shown in the Actions panel doesn't match what you expected, you've found the problem.

Fix: Add an AGENTS.md file to your project root that describes the directory layout explicitly:

# Project Structure
- Web app: apps/web/src/
- API server: apps/api/src/
- Shared packages: packages/shared/src/
 
Always use full paths from the project root when referencing files.

This single file eliminates the majority of path-mismatch issues because the agent reads it at the start of every session.

Pattern 3: File Permission Error

The agent attempted to write the file, but the OS blocked it. On macOS in particular, Antigravity needs Full Disk Access to modify files in certain directories — especially in areas like ~/Documents or Dropbox-synced folders. Without the right permission, writes fail without surfacing any visible error in the chat.

How to check: Look at the Antigravity logs for system-level errors:

# macOS — search for permission errors in Antigravity logs
cat ~/Library/Logs/Antigravity/antigravity.log | grep -i "EACCES\|EPERM\|permission denied" | tail -20

If you see EACCES or EPERM, the OS is blocking the write.

Fix options:

macOS Full Disk Access: System Settings → Privacy & Security → Full Disk Access → add Antigravity, then restart the app
Read-only file flag: chmod 644 path/to/file to make the file writable
.gitattributes lock: Check if the file has lockable or similar attributes preventing writes
Sync app conflict: If the file is inside a Dropbox or iCloud Drive folder that is syncing, temporarily pause sync and try again

Pattern 4: Your Editor Is Showing a Cached Version

Antigravity did write the file — but your editor is still displaying the pre-change version from its buffer. This tends to happen when you have the same file open in both Antigravity's built-in editor and an external editor like VS Code, Cursor, or Zed. Each editor maintains its own buffer, and they don't always auto-refresh when another process writes to disk.

How to check: Bypass the editor entirely and read the file directly from the terminal:

# Read from disk, not from any editor buffer
cat src/utils/auth.ts | grep -n "try\|catch\|error"

If the agent's changes appear in the terminal output but not in your editor, the file was written successfully. Your editor just hasn't updated its view.

Fix: Close and reopen the file in your editor. In VS Code, Cmd+Shift+P → Revert File forces a reload from disk. Working exclusively within Antigravity's built-in editor avoids this problem entirely, since it reads directly from disk after each agent write.

Pattern 5: Git Swallowed the Changes

The agent made the changes, but something in the git workflow caused them to disappear. A common scenario: the agent runs a git command as part of its process — a stash, a checkout, or a reset — that overwrites the working tree before you had a chance to verify the output.

A subtler variant: the modified file is listed in .gitignore. In this case, git status shows nothing, which can look like nothing changed — but the file may actually have been written correctly. The git output is simply not tracking it.

How to check:

git status          # Is the expected file shown as modified?
git diff            # Does the diff match what the agent described?
git stash list      # Did anything get accidentally stashed?
git log --oneline -5  # Were any commits created automatically?

Fix: If changes ended up in the stash, retrieve them with git stash pop. If the agent committed something automatically that you didn't intend, git reset HEAD~1 undoes the most recent commit while keeping the file changes. To prevent the agent from running git commands without your approval in the future, add this to AGENTS.md:

Never run git commands (commit, stash, checkout, reset) unless I explicitly ask.

The 5-Minute Diagnostic Flow

When you're not sure which pattern applies, run through these checks in order. Most issues resolve by step 2.

Step 1 (30 seconds): Check the current mode. If Planning Mode is active, switch to Fast Mode and re-run the request.

Step 2 (1 minute): Open the Actions panel and check the exact file path the agent used. Compare it to where your file actually lives in the project.

Step 3 (1 minute): Use cat in the terminal to read the file directly, bypassing any editor cache.

Step 4 (1 minute): Run git status, git diff, and git stash list to rule out git-related disappearance.

Step 5 (1 minute): Search the Antigravity log for EACCES or EPERM to check for permission errors.

In practice, you'll rarely need to go past step 3. Planning mode and path mismatches account for roughly 80% of cases.

Making This a Non-Issue Going Forward

A few habits and settings go a long way toward preventing this from recurring.

Write an AGENTS.md from the start. Even a five-line file describing your directory structure gives the agent a reliable map. Do this when you initialize a project, not after you've already lost an hour to path confusion. Projects with an AGENTS.md file tend to have significantly fewer agent errors overall.

Keep the Output panel visible. View → Output → Antigravity shows the agent's live actions including any errors. A permission denial or a missing path shows up immediately rather than disappearing silently into the logs.

Verify after complex edits. After a multi-file refactor, ask the agent: "Show me the current content of each file you just modified." This adds maybe 30 seconds and catches silent failures before you move on and compound the problem.

Use Planning Mode deliberately. It's a genuinely useful tool for reviewing the approach before committing to large changes — but it requires an explicit "apply" step that's easy to forget. Be intentional about when you're in it versus Fast Mode.

The next practical step: create an AGENTS.md in your current project right now. It takes two minutes to write and prevents an entire class of frustrating, hard-to-diagnose problems from recurring.