---
title: "Enable YOLO Mode in Antigravity and the agy CLI | AgentRQ Guidelines"
url: https://agentrq.com/guidelines/yolo-mode/antigravity
description: "Antigravity's YOLO mode is the Turbo preset in the IDE and --dangerously-skip-permissions in the agy CLI. There is no agy --yolo. Settings and safe use."
---

![](https://agentrq.com/assets/agent-icons/antigravity.png) Checked October 7, 2026 | [All YOLO Mode guides](https://agentrq.com/guidelines/yolo-mode/)

# Enable YOLO Mode in Antigravity and the agy CLI

Google Antigravity has no switch called YOLO, and `agy --yolo` is not a flag. Its YOLO mode is the **Turbo** permission preset in the Antigravity IDE, and `agy --dangerously-skip-permissions` in the Antigravity CLI. Both let the agent run commands and edit files without asking you first.

This page is one of our [YOLO mode guides](https://agentrq.com/guidelines/yolo-mode/), and part of our guide to [YOLO mode in every coding agent](https://agentrq.com/blog/what-is-yolo-mode-and-how-to-turn-it-on-in-every-coding-agent). Everything below was checked against Google's Antigravity documentation at antigravity.google/docs on October 7, 2026. Google does not publish the CLI's full flag list, so where a setting is only described in passing, we say so.

![Antigravity YOLO mode at a glance: Turbo preset in the IDE, agy --dangerously-skip-permissions, toolPermission always-proceed, and per-task YOLO in AgentRQ](https://agentrq.com/assets/guidelines/yolo-mode-antigravity-og.png)

## What YOLO Mode Turns Off in Antigravity

Antigravity has an approval layer and a separate terminal sandbox, and the two YOLO switches treat them differently.

- → **Turbo in the IDE turns off both.** Commands run without asking, the sandbox is off, the agent can reach the whole filesystem, and MCP and web tools are allowed.
- → **The agy flag turns off approvals only.** `--dangerously-skip-permissions` approves every tool request for that session. The terminal sandbox is controlled separately, by `--sandbox` and the `enableTerminalSandbox` setting, and it is off by default.

So in the CLI, "YOLO" leaves you exactly as sandboxed as you were before, which by default means not at all.

## Does agy --yolo Exist?

No. Google's CLI reference does not list `--yolo`, and running `agy --yolo` will not put the agent in YOLO mode. The flag you want is:

bash

```bash
agy --dangerously-skip-permissions
```

The name follows Claude Code's flag of the same name. Google's CLI guide mentions it as one of the launch flags, alongside `--sandbox`, that override your saved settings for one session. The settings panel then shows that the value came from a flag.

## How to Enable YOLO Mode in the agy CLI

| Where | Full YOLO | Halfway |
| --- | --- | --- |
| Command line | `agy --dangerously-skip-permissions` |  |
| settings.json | `"toolPermission": "always-proceed"` | `"toolPermission": "proceed-in-sandbox"` |
| In a session | `/permissions` | `/permissions` |
| Rules |  | `"permissions": {"allow": [...]}` |

### Make YOLO the Default in settings.json

The CLI keeps its settings in `~/.gemini/antigravity-cli/settings.json` and only writes the values you change. The key that matters is `toolPermission`:

json

```json
{
  "toolPermission": "always-proceed"
}
```

It accepts four values:

- → `request-review`, the default, asks before writes, shell commands and web tools.
- → `proceed-in-sandbox` runs terminal commands without asking as long as they stay in the sandbox, and asks otherwise. This is the halfway setting, and it only helps if the sandbox is on.
- → `strict` asks before every tool that is not a read.
- → `always-proceed` never asks. This is YOLO.

### Switch agy to YOLO Mode Inside a Session

`/permissions` opens the interactive permissions manager, where you can change the mode and the rules for the running session. `/config` (or `/settings`) opens the full settings editor. When the agent is waiting on a subagent's action, `Ctrl+K` approves that one action.

### Per-Command Rules in agy

For something between asking and YOLO, write rules. They go in a `permissions` block with `allow`, `ask` and `deny` lists:

json

```json
{
  "permissions": {
    "allow": ["command(git)", "command(npm test)", "write_file(src/)"],
    "deny": ["command(rm)"]
  }
}
```

Rules can match commands (including `command(regex:...)`), file writes, URLs and MCP tools such as `mcp(server/tool)`. A deny beats an ask, and an ask beats an allow.

## How to Enable YOLO Mode in the Antigravity IDE

On macOS and Linux, open **Settings > General > Permission Settings** and pick a preset. A project can override it or choose **Inherit General**.

| Preset | Sandbox | Terminal commands | Files | MCP and web |
| --- | --- | --- | --- | --- |
| Default | On | Run freely inside the sandbox, ask outside it | Workspace and temp | Ask |
| Request Review | Off | Always ask | Workspace only | Ask |
| Turbo | Off | Run without asking | Whole filesystem | Allowed |

**Turbo** is the Antigravity YOLO mode. **Default** is the halfway setting, and for most work it is the better one: the agent runs freely as long as it stays inside the sandbox, and stops only when it wants out.

On Windows, Antigravity still uses its older permission settings. Set **Terminal Command Auto Execution** to **Always Proceed**, which still respects your deny list, and set the outside-of-folder file access policy to **Always Allow**. Sandbox mode is a separate toggle there.

Two more IDE settings are worth knowing. The **artifact review policy** decides whether the agent waits for you to review its plans and other artifacts (`asks-for-review`, `agent-decides` or `always-proceed`). **Strict mode** does the opposite of Turbo: it sends terminal commands, browser JavaScript and artifacts to review and turns the sandbox on with no network.

## Antigravity 2.0 and Gemini CLI

"Antigravity 2.0" shows up in forum posts, but we found no official 2.0 page about permissions. The presets above are what Google documents today. If you are coming from Gemini CLI, note that Google moved its free and Google AI Pro and Ultra users from Gemini CLI to the Antigravity CLI in 2026, and that `gemini --yolo` habits do not carry over: in `agy` the flag is `--dangerously-skip-permissions`. Our [Gemini CLI YOLO guide](https://agentrq.com/guidelines/yolo-mode/gemini-cli) covers the old tool.

## How to Enable YOLO Mode in Antigravity Through AgentRQ

Antigravity's own YOLO switch covers a whole session. AgentRQ lets you make the decision per task, and answer from somewhere other than the terminal.

### Approve From the AgentRQ Task Instead of the Terminal

Connect the Antigravity agent to an AgentRQ workspace through the [ACP Gateway](https://agentrq.com/docs/connect-acp-agent) ([Antigravity setup guide](https://agentrq.com/docs/agents/antigravity)). Its registry build publishes no checksum, so the first run needs `--allow-unverified-agent`:

bash

```bash
npx @agentrq/acp-gateway@latest --agent antigravity-acp --allow-unverified-agent
```

Then start it without `--dangerously-skip-permissions` or the `always-proceed` setting. The gateway also moves each new session out of any mode that would approve on its own and into one where the agent asks a person. Each permission request now shows up in the AgentRQ task on the web, on your phone or in Slack, together with the command or edit it is asking about. Answer **Allow Once**, **Always Allow** or **Deny** from wherever you are, and Antigravity carries on. If nobody answers within 30 minutes, the gateway cancels the turn instead of guessing. Change the limit with `--permission-timeout`.

### Turn On YOLO for One Task

Flip the **YOLO** toggle on a task, or when you create it, to put just that task in [YOLO mode](https://agentrq.com/features/yolo-mode). Every permission request in it is approved automatically and Antigravity never waits, while every other task in the workspace still asks. [Scheduled tasks](https://agentrq.com/features/task-scheduling), [event triggers](https://agentrq.com/features/events) and [workflow](https://agentrq.com/features/workflows) steps have the same switch, so an unattended job can run in YOLO while your interactive work stays supervised.

### A Safe YOLO Setup for Antigravity

- → **Allow the boring tools, not everything.** **Always Allow** adds the tool to the workspace's auto-approved list, so the routine calls stop asking and the risky ones still do. Prune that list in workspace settings now and then.
- → **Leave the workspace-wide switch off.** Workspace settings also has **YOLO Mode (Execute All)**. Turn YOLO on per task instead, so it never outlives the job you trusted.
- → **Keep the terminal sandbox on.** Set `"enableTerminalSandbox": true` in the agy settings. Approvals and the sandbox are separate in Antigravity, so per-task YOLO in AgentRQ still runs every command inside it.
- → **Commit first.** Start every YOLO task from a clean git tree, so any change is one `git reset` away.
- → **Read the record.** The [tool call history](https://agentrq.com/features/tool-call-history) lists every call the task made, including the ones that were auto-approved.

## FAQ

**Does agy --yolo exist?** No. The agy CLI has no `--yolo` flag. Use `agy --dangerously-skip-permissions`, or set `"toolPermission": "always-proceed"` in `~/.gemini/antigravity-cli/settings.json`.

**How do I enable YOLO mode in Antigravity CLI?** Start it with `agy --dangerously-skip-permissions` for one session, or set `toolPermission` to `always-proceed` to make it the default.

**What is agy cli yolo mode?** It is the always-proceed tool permission: the agent runs shell commands, edits and web tools without asking. It does not turn the terminal sandbox on or off.

**How do I enable YOLO mode in Antigravity?** In the IDE on macOS and Linux, choose the Turbo preset under Settings > General > Permission Settings. On Windows, set terminal auto execution to Always Proceed.

**What is Antigravity Turbo mode?** Turbo is the IDE preset with no sandbox, no command prompts, full filesystem access and MCP and web tools allowed. It is Antigravity's YOLO mode.

**Is there an Antigravity 2.0 YOLO mode?** Google has not published a separate 2.0 permission model. The YOLO options are still the Turbo preset in the IDE and `--dangerously-skip-permissions` in agy.

**How do I approve Antigravity commands remotely?** Connect the agent to [AgentRQ](https://agentrq.com) through the ACP Gateway. Its permission requests show up in the task on the web, your phone or Slack.

For every other agent, see [what YOLO mode is and how to turn it on in every coding agent](https://agentrq.com/blog/what-is-yolo-mode-and-how-to-turn-it-on-in-every-coding-agent).