Settings

Antigravity features a hierarchical settings architecture designed to give you granular control over your development environment. Settings are split between global application preferences and isolated project-level boundaries to ensure robust security and flexible workspace configurations.

You can open the Settings panel using any of the following methods:

• Keyboard shortcut: Press Cmd + , on any active surface inside the application.
• Sidebar navigation: Click Settings at the bottom of the left sidebar.
• Project settings: Click the gear icon located next to a specific project.

Settings are organized into four distinct scopes to keep configurations clean and isolated:

Global settings apply across all workspaces:

• Account settings: Manage authentication sessions and toggle telemetry (enable or disable sharing interaction logs to improve models).
• Global permissions: Centralized default tool boundaries that apply to all conversations.
• Appearance: Customize visual themes and panel layouts.
• Browser integration: Configure how the agent interacts with web surfaces.
• Model usage: Choose and configure default reasoning models.
• Customizations: Manage Model Context Protocol (MCP) servers, custom skills, and plugins.

Project settings apply exclusively within the scope of a specific project:

• Folders: Define the list of local folders associated with the project. Antigravity automatically detects Git configurations for these folders to handle conversation targets:
  • Local: Select this in the new conversation view to work directly in the existing folders.
  • Worktree: Select this to start a new worktree in the folders. If a folder does not have Git, the existing local folder is used instead.
• Agent settings: Configure project-specific agent behaviors:
  • Permission settings (macOS and Linux): Choose the project’s permission preset—Inherit General, Default, Request Review, or Turbo—controlling how the agent runs shell commands, accesses files, and uses the terminal sandbox (refer to Agent permissions).
  • Terminal execution policy (Windows): Control how the agent runs shell commands.
  • Outside of folder file access policy (Windows): Define how the agent accesses files outside the project boundary (Always Allow, Always Ask, or Always Deny).
  • Sandbox mode (Windows): Toggle the terminal sandbox container on or off within the custom security preset (refer to Terminal sandbox).
• Project-level permissions: Configure permissions at the project level. As you interact with an agent, you accumulate permission requests that can be automatically added to project permissions.
• Customizations: Derived from both global and project-specific customizations. You can view all skills originating from each folder added to the project.

You can also start conversations outside of a project:

• Behavior: Standalone conversations do not have a configurable folder and instead run in a local scratch directory.
• Settings: Standalone conversations can have their own settings (such as terminal execution, file access policies, and permissions) similar to projects, but operate independently of any project structure.

Access shortcuts and feedback tools:

• Shortcuts: View and customize keyboard shortcut configurations.
• Feedback: Access the feedback form to send reports directly to the team.

The Enable Telemetry setting is located in the Settings panel under the Account section. When toggled on, Antigravity collects interactions for use in evaluating, developing, and improving Antigravity and models that support Antigravity.

Configure persistent preferences, customize keyboard shortcuts, toggle terminal display buffers, and manage runtime CLI parameter overrides.

Antigravity CLI stores user preferences in a minimal, forward-compatible JSON configuration profile.

The persistent settings are saved in a plain JSON format:

~/.gemini/antigravity-cli/settings.json

The CLI leverages sparse persistence by writing only values to disk that differ from their system defaults. This keeps your configuration file clean, minimal, and fully forward-compatible with future updates.

To edit settings directly inside your active terminal session without opening raw JSON files:

1. Type /config (or its alias /settings) inside the prompt panel and press Enter.
2. The full-screen Settings Editor Overlay opens.
3. Navigate between available options using ↑/↓.
4. Press Enter on a highlighted parameter to toggle its state or open a text insertion field.
5. Press Esc to save your modifications and close the editor.

You can temporarily override persistent preferences for individual terminal sessions using CLI command flags:

agy --sandbox --model="Gemini 3.5 Flash"

When an override flag is active, the interactive /config menu displays a warning indicator alongside the modified setting:

! Tool Permission: strict (overridden by command flag)

You can still edit the persistent value on disk during these sessions, but the CLI enforces the active runtime flag override until you close the session.

The TUI operates in one of two visual rendering modes depending on your terminal capability and connection latency.

This mode opens a dedicated display screen using the terminal’s alternate buffer, creating an immersive, standalone app interface:

• Key features: Integrated scrollback, mouse-wheel scrolling support, custom rendered scrollbar, and clean terminal state restoration on exit.
• Best used for: Standard local development sessions in advanced terminal emulators (such as iTerm2, Ghostty, or WezTerm).

This mode renders output sequentially directly within your terminal’s standard stdout pipeline:

• Key features: Preserves entire session history inside your emulator’s native scrollback buffer, does not capture mouse inputs, and works seamlessly alongside standard command outputs.
• Best used for: Remote SSH terminals, terminal multiplexers such as tmux or screen, and low-bandwidth remote sessions.

The interactive settings panel (/config) and settings.json allow you to customize the CLI’s behavior across several categories.

Manage how the agent interacts with your system and codebase:

• Tool Permission (toolPermission): Controls the authorization flow for tools (such as running terminal commands):
  • request-review (default): Prompts for your approval before running write, bash, or web tools.
  • proceed-in-sandbox: Automatically runs terminal commands if they are sandboxed; otherwise prompts for review.
  • strict: Prompts for all non-read tools, ensuring maximum control.
  • always-proceed: Runs all tools without prompting (highest risk, use with caution).
• Artifact Review (artifactReviewPolicy): Controls when the agent prompts you to review generated artifacts (such as code files) before writing them to disk:
  • asks-for-review (default): Always prompts you to review changes.
  • agent-decides: The agent decides whether to prompt based on the complexity of the change.
  • always-proceed: The agent writes changes directly without prompting (maximizes autonomy, but increases risk of overwriting code without review).
• Sandbox Mode (enableTerminalSandbox): When enabled (on), restricts all agent-initiated terminal commands to a secure OS container.
• Non-Workspace Access (allowNonWorkspaceAccess): Controls whether the agent can read or write files outside your active project directories. Set to off by default for safety.

Customize the visual experience of the TUI:

• Rendering Mode (altScreenMode): Controls how the TUI utilizes your terminal buffer:
  • default: Adaptive mode. Uses Alt-screen on advanced local terminals and degrades to inline mode over SSH.
  • always: Forces Alt-screen mode, providing an immersive, page-based interface with mouse support and scrollbars.
  • never (configurable in settings.json): Forces inline mode, rendering output sequentially and preserving history in your emulator’s scrollback.
• Color Scheme (colorScheme): Selects the visual theme. Options include terminal (inherits shell colors), dark, light, solarized dark/light, tokyo night, and colorblind-friendly variants.
• Animation Speed (runningLightSpeed): Adjusts the speed of the progress indicator animation (fast, medium, slow, or off).
• Verbosity (verbosity): Controls detail level. high shows full agent thoughts and tool steps; low shows only minimal progress indicators.

Configure integrations with your host environment:

• Editor (editor): The text editor used to view artifacts or compose prompts (using Ctrl + G). Defaults to auto (respects $EDITOR), but can be set to vim, emacs, or others.
• Editor Mode (editorMode): The editing model used inside the CLI prompt itself. Defaults to default (flat text editing); set it to vim for modal editing. Refer to Vim editor mode. This is independent of the editor setting above, which only selects an external program.
• Notifications (notifications): When enabled (on), triggers a system desktop notification and a terminal bell chime when a long-running task completes or requires your attention.

Manage usage, tips, and telemetry:

• Use AI Credits (useG1Credits): External builds only. When enabled (on), allows the CLI to use your personal AI credits for model calls if your plan’s standard quota is exhausted.
• Enable Telemetry (enableTelemetry): Helps Google improve the tool by sending anonymous usage statistics and crash reports.
• Show Tips (showTips): Toggles the display of helpful usage tips while the agent is generating responses.
• Show Feedback Survey (showFeedbackSurvey): Enables periodic brief surveys after task completions to help improve the experience.

For advanced TUI environment integrations, you can toggle active metrics or deploy custom scripts to generate dynamic status bars and modify your terminal window titles:

• Status line customization: Learn how to manage the status indicator panel and construct custom formatted status line shell scripts.
• Terminal title customization: Learn how to toggle window title outputs and pipe live agent states into your window headers.

You can customize almost all keyboard shortcuts in the TUI by mapping keys to specific workspace commands.

Custom maps are stored alongside your primary settings profile:

~/.gemini/antigravity-cli/keybindings.json

The JSON structure maps a single TUI command action to an array of hotkey sequences:

{
  "cli.clear_screen": ["ctrl+l"],
  "prompt.insert_newline": ["shift+enter", "ctrl+j"],
  "edit.open_editor": ["ctrl+g"]
}

To completely disable a default hotkey, map its action to an empty array []. If your JSON schema is malformed or invalid, the CLI falls back to system defaults for those specific actions and loads the remaining valid mappings.

To revert all keys back to system defaults, delete the keybindings profile:

rm ~/.gemini/antigravity-cli/keybindings.json

Now that you configured your environment, review security controls and extensibility options:

• Permissions and sandbox: Manage secure execution containment boundaries.
• Plugins and skills: Create your own custom skills and import legacy plugins.
• CLI reference: Access quick reference sheets listing all configuration options, commands, and default key maps.

Configure how the Antigravity agent interacts with your environment, executes commands, and secures your workspace.

Controls how the agent executes generated shell commands:

• Request Review: The agent always prompts for confirmation before executing any terminal command (except those explicitly added to your configurable allowlist).
• Always Proceed: The agent executes commands automatically without prompting (except those explicitly added to your configurable denylist). High autonomy, high risk.

Allows the agent to view and edit files outside active project folders:

• By default, the agent only has access to the folders inside your project and the local app data directory ~/.gemini/antigravity-ide/ (which contains artifacts, knowledge items, and configuration files).
• Enforcing this boundary protects your local sensitive data. Enable non-workspace access with caution.

Strict mode provides enhanced security controls for the agent, allowing you to restrict its access to external resources and sensitive operations. When strict mode is enabled, several security measures are enforced to protect your environment.

In strict mode, the agent’s ability to interact with external websites is governed by the browser’s allowlist and denylist. This applies to:

• External Markdown images: The agent only renders images from URLs that are allowed.
• Read URL tool: The Read URL tool only auto-executes for allowed URLs.

Strict mode enforces the following behavior for terminal, browser, and artifact interactions:

• Terminal auto execution: Set to “Request Review”. The agent always prompts for permission before executing any terminal command. The terminal allowlist is ignored when strict mode is enabled.
• Browser JavaScript execution: Set to “Request Review”. The agent always prompts for permission before executing JavaScript in the browser.
• Artifact review: Set to “Request Review”. The agent always prompts for confirmation before acting on plans laid out in artifacts.

Strict mode restricts the agent’s access to the file system to ensure it only interacts with authorized files:

• Respect .gitignore: The agent respects .gitignore rules, preventing it from accessing ignored files.
• Workspace isolation: Access to files outside the workspace is disabled. The agent can only view and edit files within the designated workspace.

Sandboxing provides kernel-level isolation for terminal commands executed by the agent. When enabled, commands run in a restricted environment with limited file system and network access, protecting your system from unintended modifications.

Sandboxing is currently disabled by default, but this may change in future releases. It is supported on macOS and Linux. On macOS, it leverages Seatbelt (sandbox-exec), Apple’s kernel-level sandboxing mechanism. On Linux, it uses nsjail for process isolation.

You can enable or disable sandboxing in Antigravity user settings. Toggle “Enable Terminal Sandboxing” to turn sandboxing on or off. When enabled, you can also control network access separately using the “Sandbox Allow Network” toggle.

When sandboxing is enabled, the agent’s terminal commands are subject to the following restrictions:

• File system: Commands can only write to your designated workspace directory and essential system locations. This prevents the agent from accidentally deleting or modifying files outside your project.

  

• Network access: Network connectivity can be independently controlled. Use the “Sandbox Network Access” toggle in Antigravity user settings to allow or deny network access while maintaining file system restrictions.

Here’s an example of a command being blocked due to network restrictions:

When strict mode is enabled, sandboxing is automatically activated with network access denied. This ensures maximum protection when operating in a strict environment.