Antigravity Auto Mode & Auto-Accept: How to Stop the Approval Prompts

Antigravity Auto Mode and Auto-Accept: Quick Answer

Antigravity's agent asks before it edits files, runs commands, calls MCP tools or opens URLs. That is the safe default, but it makes long tasks slow. Google has now shipped native ways to cut the prompts, so most people no longer need a workaround. This guide separates the App/IDE settings from the CLI settings, explains why prompts sometimes keep appearing, and covers what auto-run can actually do to your machine.

How to Enable Auto Accept in Antigravity (App and IDE)

Current Antigravity builds use a permission preset that controls how terminal commands, file access, MCP tools and web reads are approved. Per Google's Agent settings and Permissions docs, the four presets are:

Steps: turn on Auto (Preview) or Turbo

1. Update Antigravity to v2.23.0 or later. Auto (Preview) is not offered on business or enterprise accounts.
2. Open Settings → General → Global Permissions → Permission Preset and select Auto (Preview) or Turbo. The checkmark shows your current preset.
3. Or use the permissions picker in the message box (v2.23.0+). It changes your global preset, or the project's preset if that project has its own override.
4. For one project only, go to Settings → Projects and set that project's preset. New projects default to Inherit Global. Choose Use Global Settings to remove an override.
5. Add deny rules for anything the agent must never do (see Allow & Deny Rules).

Note that the Auto preset only changes how terminal commands and workspace files are handled. MCP tools and web access stay on Ask. If you want those to stop prompting, add mcp(server/*) or read_url(domain) allow rules instead of switching to Turbo.

Plans and artifacts

Reviewing implementation plans is a separate setting. Since v2.17.0 the Agent setting that governs plan review is called Plan Review Policy, and Google's changelog says you can set it to review every plan, review only when the agent judges it worthwhile, or skip review entirely. Permission presets do not change it.

Older IDE Settings: Terminal Command Auto Execution and Artifact Review

Google's Antigravity IDE docs still describe the earlier policy-style settings, and Agent settings lists them as "previous permission settings". You may see them on older or managed installs:

• Terminal command auto execution: Request Review always asks before a terminal command, except commands on your Allow list. Always Proceed runs commands automatically, except commands on your Deny list. Google labels this "high autonomy, high risk". The Agent settings page also lists a middle option, Proceed in Sandbox, where commands run without prompting inside the terminal sandbox and anything outside it still needs review.
• Artifact review: Request Review (recommended) halts for your approval on plans and diffs. Always Proceed never halts for manual review.
• Agent non-workspace file access: off by default. The agent otherwise sees only your project folders and its own app data directory.
• Strict mode: forces terminal execution, browser JavaScript and artifact review to Request Review, and the terminal allowlist is ignored. Turn Strict mode off if your allowlist seems to do nothing.

The IDE extension also has antigravity.autoAcceptOnChat, enabled by default since the v1.6.0 extension release. When you send a new chat message, it automatically accepts pending inline diffs in background files and keeps the active file's diff open for review. Since v1.9.0 you can accept or reject the focused inline diff hunk with Alt+Enter / Alt+Shift+Enter (Option+Enter / Option+Shift+Enter on macOS).

Antigravity CLI Auto Mode: How to Use agy --mode=auto

The CLI has four execution modes. Per Google's "Choose an execution mode" page:

Steps: enable agy auto mode

1. Update the CLI. Auto mode needs v1.3.5+ on macOS and Linux or v1.4.4+ on Windows, and it requires the terminal sandbox.
2. Launch directly in auto mode:

   agy --mode=auto

3. Or switch inside a session: press Shift+Tab to cycle default > accept-edits > auto > plan. If auto is unavailable, cycling skips from accept-edits to plan.
4. To make it permanent, run /config, highlight Agent Mode, and choose auto. Or set it in ~/.gemini/antigravity-cli/settings.json:

   {
       "agentMode": "auto"
   }

5. Confirm it worked: the bottom-right status bar shows auto and the prompt box reads Auto mode: edits & safe commands auto-approved (shift+tab to cycle).

Auto mode requirements and limits

• Sandbox required. On Windows that means Windows 11 24H2 or later with the August 2026 update or later. If the sandbox is not available (Windows 10, older Windows 11 builds, or Linux hosts and containers that block unprivileged user namespaces), auto mode is not offered and the CLI starts in default.
• Headless: agy -p "..." --mode=auto works when auto is available. If it is not, the CLI prints a warning and continues in default mode.
• Overrides: explicit allow, ask and deny rules, strict tool permission and --dangerously-skip-permissions take precedence over modes.
• Subagents inherit the setting, so their file writes do not queue for approval.

How to Allow Antigravity to Run All Commands (agy Auto Approve)

If you want no prompts at all, the CLI offers two switches. Both map to the always-proceed tool permission:

1. Per run:

   agy --dangerously-skip-permissions

2. Persistent: run /config and set Tool Permission to always-proceed, or set "toolPermission": "always-proceed" in ~/.gemini/antigravity-cli/settings.json.

Google's settings reference describes always-proceed as running terminal commands, web requests and MCP tools without prompting, except actions that match an ask or deny rule, and calls it highest risk. It overrides auto mode. A Google maintainer suggested this same /config change in a GitHub feature request for an auto mode (before auto mode shipped); the reporter said it still prompted sometimes, which is a community report and is not confirmed as a bug.

Since CLI v1.3.2, --dangerously-skip-permissions no longer auto-approves the implementation plan in /plan mode. It only skips tool permission prompts. Set Artifact Review in /config to always-proceed if you want plans to proceed too.

For scripts and CI, headless mode takes -p plus the same flags, and also accepts --sandbox to run with terminal sandbox restrictions:

# Preferred for unattended runs where auto mode is available
agy -p "Fix the failing unit tests" --mode=auto --output-format json

# Allow-all in a throwaway environment only
agy -p "Refactor the utils folder" --dangerously-skip-permissions --sandbox

The same headless guide notes that a run that is not already authenticated exits with an authentication required error in non-interactive environments. Sign in with an interactive agy session first. If a command fails in your pipeline, see agy CLI errors and troubleshooting.

Why Antigravity Still Asks for Permission

If prompts keep appearing after you enabled auto mode or Turbo, check this list in order:

1. An ask or deny rule matches. Rules are evaluated Deny > Ask > Allow and always beat the preset or mode. A broad command(*) in Ask makes every command prompt, even if command(git) is in Allow.
2. The action is MCP or web. The Auto preset keeps MCP and web actions on Ask. Add mcp(...) or read_url(...) allow rules for servers and domains you trust.
3. The command is risky or irreversible. Auto mode pauses on those by design.
4. Strict tool permission or Strict mode is on. CLI strict overrides auto mode. IDE Strict mode forces Request Review and ignores the terminal allowlist.
5. The command hides shell constructs. Command or process substitution ($(...), backticks), brace expansion, risky redirections or flags that run subcommands disable prefix matching. The command then runs without a prompt only if a rule matches the full line exactly. For example, with command(git) allowed, git status && git log runs but git log $(whoami) prompts.
6. The file is outside your workspace. Non-workspace access is off by default.
7. The sandbox is unavailable. Auto mode is not offered, and from CLI v1.4.4 proceed-in-sandbox behaves like request-review.
8. Your account type. Auto (Preview) is not available for business or enterprise accounts.
9. Old version. Update. Auto mode landed in CLI v1.3.5 and the App preset in v2.23.0.

If none of these explain it, the agent may be hung rather than asking. See Antigravity not responding fix.

Antigravity Permissions: Allow and Deny Rules

Every sensitive operation is a permission resource written as action(target). Supported actions per Google's Permissions docs: read_file, write_file, read_url, execute_url, command and mcp. Precedence is Deny > Ask > Allow, and Google states that deny rules block an action in every mode.

• command(git) matches by exact word or token prefix. command(regex:npm run (build|lint|test)) matches by regular expression.
• write_file implies read_file on the same path. Denying read_file on a path also denies write_file there.
• read_url(domain) also feeds the terminal sandbox's outbound network allowlist, so curl and npm can reach only hosts you granted.
• In the CLI, edit rules with /permissions or in ~/.gemini/antigravity-cli/settings.json. In the App, use Global Permissions or the project's permission settings. You can also edit the target on a permission prompt card to widen a one-off grant (not supported for terminal commands).

Example CLI rules adapted from Google's documentation:

{
    "permissions": {
        "allow": [
            "command(git)",
            "command(regex:npm run (build|lint|test))",
            "write_file(src/)",
            "mcp(linter/*)"
        ],
        "deny": [
            "command(rm -rf)",
            "command(regex:curl .*)",
            "command(sudo)",
            "write_file(.git/)",
            "write_file(/home/user/.ssh)"
        ],
        "ask": ["command(*)", "mcp(sql/execute_mutation)"]
    }
}

Heads up: in this example command(*) in Ask would override the command(git) allow rule per the precedence rule, so use ask for specific risky prefixes, not for *, if you want allow rules to take effect.

Safety: What Antigravity Auto-Run Can Do

Auto-approval does not make the agent smarter. It removes the pause where you would have caught a mistake. What that means depends on the setting:

Practical controls that hold up in any mode: commit before long runs, work on a branch or worktree, add the deny rules above, keep secrets out of the workspace, and run unattended jobs on a disposable VM or container. For a fuller checklist, see preventing dangerous commands and protecting files.

About ignore files: Google's IDE docs document Strict mode as respecting .gitignore. The CLI changelog mentions .antigravityignore in a path-completion fix, but the docs do not present it as a security boundary. Use deny rules such as read_file(.env) to protect secrets instead of relying on an ignore file. (We removed our earlier .antigravityignore template for this reason; see also agent loading guide.)

Ralph Loop, SuperSmooth and Other Auto-Accept Extensions: Do You Still Need Them?

For approvals, usually no. These projects predate the native presets and CLI modes. Everything below is community-reported from each project's own README, not Google guidance, and none of it is vetted by Google.

Our earlier version of this guide listed settings keys such as ralphLoop.autoRunCommands and superSmooth.autoProceed. We could not find them in the current project READMEs, so they were removed. If you already installed an extension, check its current README before trusting an old config.

Recommended Setup: Auto Mode With a Deny List

This is the setup we would use for day-to-day work. It cuts most prompts and keeps the hard stops.

1. Commit or branch first. A clean git state turns a bad run into git restore . or a discarded branch.
2. Pick auto, not Turbo. App: Permission Preset → Auto (Preview). CLI: agy --mode=auto.
3. Add deny rules for destructive commands and sensitive paths (command(rm -rf), command(sudo), command(regex:curl .*), write_file(.git/), read_file(.env), SSH and cloud credential folders).
4. Allow known-good commands with prefixes such as command(git) and command(regex:npm run (build|lint|test)).
5. Leave non-workspace access off and keep MCP and web on Ask until you trust a specific server or domain.
6. Add rules in plain language through your rules file for conventions the permission engine cannot express. See custom rules and workflows. Rules are guidance to the model, not enforcement, so keep deny rules as the hard stop.
7. Review the diff before you merge. Auto-approved does not mean correct.

What Changed in 2026 (and What This Guide Replaced)

• September 22, 2026, App v2.17.0: Artifact review became Plan Review Policy (review every plan, review when worthwhile, or skip).
• September 29, 2026, IDE extension v1.6.0: antigravity.autoAcceptOnChat added.
• October 12, 2026, App v2.23.0: permissions picker in the message box. Docs list Auto (Preview) as available from this version.
• October 14, 2026, CLI v1.3.5: auto mode added (--mode auto, /config Agent Mode, Shift+Tab) on Linux and macOS.
• October 15, 2026, CLI v1.3.6: faster auto mode sandbox-escape reviews that no longer time out without a decision.
• CLI v1.4.4: auto mode on Windows where the sandbox is available.
• October 19, 2026, IDE extension v1.9.0: keyboard shortcuts to accept or reject the focused inline diff hunk.

The earlier version of this guide said Google had no official autopilot and described a three-mode "Terminal Execution Policy" of Off, Auto and Turbo. That is out of date. Google now documents presets (Request Review, Default, Auto, Turbo) in the App and execution modes in the CLI. We also removed unsourced statistics and usage claims from the earlier version.

Earlier Guidance (March 2026)

The Approval Problem: Why Developers Want Auto-Accept

Every time Antigravity's agent wants to perform an action (writing a file, running a terminal command, invoking an MCP tool, or browsing a URL) it pauses and asks for your approval. This is a deliberate safety measure: it keeps a human in the loop and prevents the agent from executing potentially destructive operations without oversight.

The problem is that for routine, low-risk workflows, the constant interruptions destroy productivity. Consider a typical scenario: you ask the agent to scaffold a new feature with a database migration, API route, frontend component, and unit tests. The agent needs to:

• Create 6–8 new files (each requires approval)
• Run npm install for a new dependency (approval)
• Execute the database migration command (approval)
• Run the test suite to verify (approval)
• Fix any failing tests and re-run (approval for each edit + each command)

That's 15–20 manual approvals for a single feature. Multiply that across a full workday, and developers reported clicking "Accept" or "Run" upwards of 200 times per session. Some community members reported leaving Antigravity running for hours without needing to intervene once, but only after configuring their setup properly.

The Built-in "Always Run" Setting (And Why It Sometimes Fails)

Antigravity includes a built-in mechanism to auto-approve certain operations. In March 2026 it was called the Terminal Execution Policy, under Settings → Antigravity → Terminal Execution Policy, with three modes:

• "Off" (Allow List Only): The agent cannot execute any command without explicit approval. Safest, but slowest.
• "Auto" (Default): The agent uses an internal safety classifier to decide which commands are "safe" to run without asking. Commands like ls, cat, and npm test auto-execute; commands like rm -rf or chmod still require approval.
• "Turbo" (Deny List Only): The agent executes everything except explicitly blocked commands. Fastest, but most dangerous.

Why "Auto" mode didn't feel like autopilot: Even in Auto mode, the agent still paused for file edits, MCP tool invocations, and browser actions. Terminal commands are only one category of approval, and file writes and tool calls were governed by separate settings. The internal safety classifier was also conservative: it frequently flagged commands like npx prisma migrate dev, docker compose up, and even git commit as requiring manual approval because they modify state.

Ralph Loop: The Community's Go-To Auto-Accept Extension

Ralph Loop was described in March 2026 as a community-built Antigravity extension that automates the approval flow by programmatically clicking the "Accept" and "Run" buttons whenever the agent pauses for confirmation, created after developers found the built-in settings were not enough for hands-free operation.

What Ralph Loop Does

• Auto-accepts file edits: when the agent presents a diff, Ralph Loop clicks "Accept" automatically.
• Auto-runs terminal commands: when the agent requests permission to execute a command, it clicks "Run."
• Auto-proceeds tool calls: MCP tool invocations and browser actions are approved without manual intervention.
• Configurable delay: you can set a delay (in milliseconds) between the approval prompt appearing and the auto-click, giving you a window to manually cancel if needed.

Community members reported using Ralph Loop to generate entire 350-page documentation sites hands-free, leaving Antigravity running for multiple hours (community-reported (March 2026), not independently verified).

Installation

# Install via the Antigravity Extension Marketplace
# Search for "Ralph Loop" in the Extensions panel
# Or install from the command palette:
Ctrl+Shift+P > "Extensions: Install Extension" > search "Ralph Loop"

Configuration

In March 2026 the guide said to open Settings → Extensions → Ralph Loop and configure the following. These keys are community-reported (March 2026), not found in current README:

{
  "ralphLoop.enabled": true,
  "ralphLoop.autoAcceptEdits": true,
  "ralphLoop.autoRunCommands": true,
  "ralphLoop.autoApproveTools": true,
  "ralphLoop.delayMs": 1500,
  "ralphLoop.excludeCommands": [
    "rm -rf",
    "DROP",
    "git push --force",
    "chmod -R 777"
  ]
}

SuperSmooth: Fixing Auto-Proceed and Auto-Scroll

SuperSmooth was described as a companion extension for a related problem: even with auto-accept enabled via built-in settings or Ralph Loop, the Antigravity UI often failed to scroll to the latest output and didn't automatically proceed to the next step in multi-step tasks.

What SuperSmooth Fixes

• Auto-proceed: When the agent finishes one step and the UI shows a "Proceed" or "Continue" button, SuperSmooth clicks it automatically. Without this, the agent paused between steps even with auto-accept enabled.
• Auto-scroll: Keeps the chat output scrolled to the bottom so you can monitor progress. Antigravity's native scroll behavior often got stuck mid-conversation during long operations.
• "Always Proceed" issue fix: Several versions of Antigravity had a bug where the "Always Proceed" toggle in the settings panel didn't persist across sessions. SuperSmooth was reported to patch this by intercepting the UI state and forcing the proceed behavior.

# Install SuperSmooth
Ctrl+Shift+P > "Extensions: Install Extension" > search "SuperSmooth"

# Configuration (settings.json), community-reported (March 2026)
{
  "superSmooth.autoProceed": true,
  "superSmooth.autoScroll": true,
  "superSmooth.fixAlwaysProceed": true
}

In March 2026, SuperSmooth was said to work well alongside Ralph Loop: Ralph Loop handled "accept/run" approvals while SuperSmooth handled "proceed/continue" transitions and scrolling.

Other Community Auto-Accept Extensions

Beyond Ralph Loop and SuperSmooth, several other community extensions attempted to solve the auto-accept problem. This is what was reported in March 2026 (community-reported, not re-verified):

AG Auto-Approve

A lightweight alternative to Ralph Loop that focuses exclusively on terminal command approval. It doesn't handle file edits or MCP tools, only shell commands. Useful if you want to auto-run commands but still manually review file changes. A configurable allowlist lets you specify exactly which commands can auto-execute.

Turbo Accept

A more aggressive extension that auto-accepts everything with zero delay. No configuration options, no exclude lists, no safety nets. It's essentially "click yes to everything as fast as possible." Community consensus at the time: useful for throwaway experiments and prototyping, dangerous for anything you care about.

Keyboard Macro Approach

Some developers skip extensions entirely and use OS-level keyboard macro tools (like AutoHotkey on Windows or Hammerspoon on macOS) to detect the approval dialog and send the keyboard shortcut for "Accept." This approach is brittle, because it breaks when the UI layout changes, but it does not depend on the extension API.

Security Implications: What You're Actually Risking

Every auto-accept extension fundamentally does the same thing: it removes the human review step from the agent's execution loop. Before enabling any form of autopilot, understand what the agent is capable of doing when given unrestricted access:

The risk is not theoretical. Security researchers have written about agents with unrestricted permissions reading .env files and sending credentials to external URLs, and a widely shared incident involved an agent deleting the contents of a user's drive after misreading a vague instruction. We did not cite a primary source for these in March 2026, so treat the specific incidents as community-reported (March 2026). Auto-accept is a productivity multiplier, but it is also a risk multiplier.

Recommended: The "Guarded Autopilot" Setup

The March 2026 recommendation was to auto-accept safe operations while requiring manual approval for destructive ones. The guide claimed this gave about 80% of the speed benefit with 95% of the safety. Those percentages were an editorial estimate, not a measurement.

Step 1: Configure the Terminal Policy

Set the Terminal Execution Policy to "Auto" and add a custom deny list for dangerous commands:

# Settings > Antigravity > Terminal Execution Policy
Terminal Execution Policy: "Auto"

# Add to your deny list:
rm -rf
rm -r /
chmod -R 777
git push --force
git reset --hard
DROP TABLE
DROP DATABASE
curl * | bash
wget * | sh
sudo *
shutdown
reboot

Step 2: Configure Artifact Review

Set the Artifact Review Policy to "Auto-Accept" for file edits within your project directory. This removed the most frequent source of approval prompts, the "Accept diff?" dialog that appears for every file the agent wants to modify. (In current builds, workspace writes are already allowed in every permission preset, and plan review is the separate Plan Review Policy.)

Step 3: Configure MCP Tool Approval

Set MCP Tool Approval to "Auto for known tools". This auto-approved tools from MCP servers you had already installed and configured, while still prompting for unknown or newly added tools. (In current builds, the Auto preset keeps MCP on Ask; add mcp(server/*) allow rules for servers you trust.)

Step 4: Install Ralph Loop with Conservative Settings

{
  "ralphLoop.enabled": true,
  "ralphLoop.autoAcceptEdits": true,
  "ralphLoop.autoRunCommands": false,
  "ralphLoop.autoApproveTools": true,
  "ralphLoop.delayMs": 2000
}

The idea was that autoRunCommands stays false, so the extension auto-accepted file edits and tool calls but left terminal commands to the built-in "Auto" policy and to you. These keys are community-reported (March 2026), not found in current README.

Using .antigravityignore and Sandboxing for Safe Automation

Before enabling any auto-accept mechanism, restrict what the agent can access. This limits the blast radius if something goes wrong.

The .antigravityignore File

In March 2026 we described this file as telling the agent which files and directories to exclude from indexing and editing, and suggested it for protecting sensitive files in autopilot workflows:

# .antigravityignore - protect sensitive files from agent access

# Credentials and secrets
.env
.env.*
*.pem
*.key
credentials.json
service-account.json

# Infrastructure configs
terraform/
.aws/
.gcloud/
docker-compose.prod.yml

# Build artifacts (also speeds up indexing)
node_modules/
dist/
.next/
build/
coverage/

For a deeper dive into optimizing your .antigravityignore for performance, see our agent loading speed guide.

Sandboxing with Docker

For maximum safety during autopilot sessions, run your project inside a Docker container. The agent can still execute commands and edit files, but its access is limited to the container's filesystem. If the agent does something destructive, you lose a container, not your host system.

# Create an isolated development container
docker run -it --rm \
  -v $(pwd):/workspace \
  -w /workspace \
  --network=host \
  node:20-slim bash

# Open the container as your workspace in Antigravity
# The agent now operates inside the container sandbox

Git as a Safety Net

Always commit your work before starting an autopilot session. If the agent makes unwanted changes across dozens of files, a single git checkout . reverts everything (git restore . is the modern equivalent). Treat autopilot sessions like experiments: branch, let the agent work, review the diff, then merge or discard.

Agent Command Execution Rules Configuration

Beyond the UI settings, the March 2026 guide described granular command execution rules in the gemini.md rules file or a workspace-level .antigravity/settings.json.

Example: Per-Project Execution Rules

# .antigravity/settings.json  (community-reported, March 2026)
{
  "agent.terminalPolicy": "auto",
  "agent.terminalDenyList": [
    "rm -rf",
    "DROP",
    "git push --force"
  ],
  "agent.terminalAllowList": [
    "npm test",
    "npm run build",
    "npx prisma migrate dev",
    "npx prisma generate",
    "git add",
    "git commit"
  ],
  "agent.autoAcceptEdits": true,
  "agent.autoAcceptEditsExclude": [
    ".env*",
    "package.json",
    "*.lock"
  ],
  "agent.mcpAutoApprove": true,
  "agent.nonWorkspaceAccess": false
}

The intent of this configuration was to auto-accept most operations, exclude sensitive files (.env, package.json, lockfiles) from auto-accept, block destructive terminal commands, and keep the agent from accessing files outside the workspace.

Example: gemini.md Rules for Autopilot Safety

You can also constrain agent behavior through natural language rules in your gemini.md file. These act as instructions the agent follows during execution. They are guidance to the model, not enforcement, so keep deny rules as the hard stop:

# gemini.md - Autopilot Safety Rules

## Command Restrictions
- NEVER run commands that delete files outside the project directory
- NEVER force-push to any branch
- NEVER modify .env files without showing me the diff first
- NEVER install packages from untrusted sources

## Workflow Rules
- Always run tests after modifying code
- Commit work in small, logical chunks
- If a test fails 3 times, stop and ask for guidance
- Do not modify infrastructure files (Dockerfile, docker-compose.yml)

For complete examples of rules files and best practices, see our workflows guide and user rules reference.

Future: Will Google Add a Native Autopilot Mode?

As of March 2026, Google had not announced an official autopilot or "unattended agent" mode for Antigravity. However, several signals suggested it was on the roadmap:

• Auto-continue is now always on: In v1.20.3, Google removed the toggle for auto-continue and made it the default behavior, eliminating the "Continue?" prompt between task steps (community-reported (March 2026)).
• The "Turbo" execution mode exists: Shipping a "deny list only" terminal mode suggested Google was comfortable with reduced human oversight for certain use cases.
• Competitor pressure: Other AI coding tools had already shipped autopilot features with configurable safety boundaries.
• Gemini API "function calling" auto-mode: The underlying Gemini API already supported automatic function calling without human confirmation, so the infrastructure for auto-execute existed at the API level.

The predicted implementation was a first-party "Autopilot Mode" with configurable guardrails, similar to the guarded autopilot setup in this guide but built into the settings UI, with allowlist and denylist for commands, file protection patterns, and a session-scoped sandbox option. In practice, that is close to what shipped as Auto (Preview) with its terminal sandbox and allow, ask and deny rules.

The March 2026 conclusion, that the extension-based approach was the community standard and that Ralph Loop + SuperSmooth + guarded settings was the most battle-tested setup, is now superseded by the native presets. The claim that thousands of developers used it daily was community-reported (March 2026) and unsourced.

Before You Enable Autopilot

Auto-accept gives the agent unrestricted power. Make sure your setup is hardened first. Read our Security Hardening Guide to understand the risks, then check the agent performance guide to ensure your agent loads fast enough for unattended operation.

Antigravity Auto Accept FAQ

Sources: Google Antigravity docs (Agent permissions, Agent settings, Settings, Choose an execution mode, Headless mode, Artifact review) and the Antigravity changelog, checked October 30, 2026. Extension details come from each project's GitHub or Marketplace README.