Antigravity CLI: Sandbox, Plugins, and Slash Commands Reference

The release of Google Antigravity CLI (agy) has introduced several terminal-based development agent paradigms. While it replaces the legacy Gemini CLI, it is not merely a replacement tool — it is a complete, concurrent development environment designed for multi-agent workflows.

In this reference guide, we will explore the core features of the Antigravity CLI, detailing how to configure the Terminal Sandbox, how the Plugin architecture is structured, how to manage Subagents, and provide a complete reference list of TUI slash commands.

TL;DR

1. Terminal Sandbox Isolation

To protect your host machine from potentially destructive code changes or unauthorized network access during agent actions, the CLI contains a native operating system sandbox layer.

Rather than running heavy containers, agy leverages native OS APIs to enforce containment boundaries with zero startup overhead:

• macOS: Enforced via sandbox-exec profiles.
• Linux: Managed via namespace isolation with nsjail.
• Windows: Isolated inside containerized AppContainer sessions.

Configuration

You can toggle or adjust sandbox boundaries inside your global configurations file (~/.gemini/antigravity-cli/settings.json):

{
  "enableTerminalSandbox": true,
  "toolPermission": "request-review"
}

• enableTerminalSandbox (boolean): Toggles general process confinement on command executions (default: false).
• toolPermission (string): Defines approval level (always-proceed, request-review, strict, proceed-in-sandbox).

Interactive Sandboxing Approvals

When the agent proposes a command, confirmation prompts adapt dynamically:

1. Sandbox Enabled: The prompt includes a bypass option ("Yes, and run without sandbox restrictions") for trusted, heavy command calls.
2. Sandbox Disabled: The prompt includes a safety option ("Yes, and run in sandbox") to execute unverified, risky scripts in containment.

Sandbox troubleshooting

Treat sandbox bypass like sudo: log who approved it and restrict to senior engineers on production machines.

2. Staged Plugin Architecture

Plugins in Antigravity CLI are namespaced directory bundles containing skills, rules, lifecycle hooks, and Model Context Protocol (MCP) server definitions grouped as a single deployable unit.

Filesystem Layout

When you install a plugin, files stage under your home directory:

~/.gemini/antigravity-cli/
├── plugins/
│   └── <plugin_name>/
│       ├── plugin.json         # Required metadata file
│       ├── mcp_config.json     # Optional MCP server definitions
│       ├── hooks.json          # Optional event hook definitions
│       ├── skills/             # Optional local agent workflows (.md)
│       ├── agents/             # Optional custom agent blueprints
│       └── rules/              # Optional workspace rules (.md)
└── import_manifest.json        # Staging registry ledger

Once staged, agy automatically crawls these folders on startup and registers the skills, hooks, and commands into active memory.

Minimal plugin.json example

{
  "name": "team-security-rules",
  "version": "1.0.0",
  "description": "Deny destructive shell patterns; load review skill",
  "skills": ["skills/security-review.md"],
  "rules": ["rules/no-force-push.md"]
}

Share plugins via git the same way you share agent skills—version bumps should trigger team-wide agy inspect smoke tests.

3. Parallel Subagents Framework

The CLI supports asynchronous task delegation. When you prompt agy with a complex goal, it does not lock your active shell. Instead, it can spawn independent subagents to work in parallel.

For example, if you ask the agent to fix a build error and document the changes, the main agent will:

1. Spawn a Testing Subagent to locate, edit, and verify the build error in an isolated Git worktree.
2. Spawn a Documentation Subagent to search files and draft matching guides in the background.

Managing approvals in TUI

When a subagent needs file write or system execution permissions, it requests confirmation. You can manage these approvals via two mechanisms:

• The /agents Panel: Type /agents in your prompt box to open the list of running, completed, or blocked subagents. Selecting a subagent opens its full console history showing every thought and step.
• Teleport Shortcuts:
  • Press Ctrl+J to instantly teleport to the detail panel of the next subagent waiting for review.
  • Press Ctrl+K to grant permission from the fast-path alert bar directly above your active prompt, without switching windows.

Subagent workflow patterns

Subagents align with loop engineering: the primary loop orchestrates; workers execute until gates pass. Review blocked subagents daily—stale permissions requests stall entire workflows.

4. CLI Core Slash Commands Reference

Antigravity CLI provides a rich set of built-in slash commands typed directly into your terminal prompt box:

Session and recovery commands

Use /fork when you want to explore a risky refactor without losing the main conversation. /rewind rolls back turns when the agent polluted context—pair with /context to verify what remains loaded. /resume switches between long-running tasks; document session IDs in team runbooks for handoffs.

5. Setting Custom Rules

To restrict or enforce conventions across your CLI agents, you can configure command permissions in ~/.gemini/antigravity-cli/settings.json under the "permissions" block:

{
  "permissions": {
    "allow": ["command(git)", "command(npm test)"],
    "deny": ["command(rm -rf)"]
  }
}

This prevents the agent from attempting dangerous system modifications while allowing common operations to proceed without prompting you for manual approval.

If you are currently migrating from Gemini CLI, follow our step-by-step transition checklist: Gemini CLI Deprecated: How to Migrate to Google Antigravity CLI (agy).

MCP and skills integration

Antigravity CLI treats MCP servers and skills as first-class plugin citizens—same architectural idea as Model Context Protocol hosts in Cursor or Claude Code.

Browse community skills at /skills and MCP servers at /mcp-servers before authoring duplicate internal plugins.

Keyboard shortcuts reference

Remap cautiously on remote SSH sessions—terminal multiplexers may intercept the same chords.

Security model vs legacy Gemini CLI

Pair CLI permissions with agent skills security review when importing third-party plugin bundles.

Example settings.json starter profile

{
  "enableTerminalSandbox": true,
  "toolPermission": "request-review",
  "permissions": {
    "allow": ["command(git)", "command(npm test)", "command(go test ./...)"],
    "deny": ["command(rm -rf)", "command(curl)", "command(wget)"]
  },
  "defaultModel": "gemini-3.5-flash"
}

Tune deny for your stack—blocking all curl breaks legitimate API debugging. Many teams allow curl only when sandbox is enabled and deny when bypass is requested.

/model and token budgeting

Switch models with /model when tasks differ: faster flash models for search and scaffolding; larger reasoning models for architecture refactors. Monitor /usage during heavy subagent days—parallel workers multiply token burn the same way multi-agent loops do in other CLIs.

When to use /btw vs full agent runs

/btw answers quick factual questions without spawning tool-heavy coding loops—use it for port numbers, flag meanings, or syntax checks. Full prompts with file edits should use normal messages so subagents, sandbox, and /diff tracking engage. Mixing modes keeps token spend predictable.

Antigravity vs other terminal agents (2026)

Pick Antigravity when your stack is Gemini-native and you want Google OAuth plus subagent panels in one TUI—not because it replaces every other agent CLI feature-for-feature.

First-week learning path

Block 30 minutes daily the first week—Antigravity rewards operators who configure guardrails before automating large refactors.

Related Reading

• Gemini CLI → Antigravity migration guide
• What is MCP?
• Loop engineering
• skills-lock.json for reproducible installs
• LLM context window explained

Summary

Antigravity CLI (agy) is Google's sandboxed, plugin-aware, multi-agent terminal: native OS containment, staged plugins under ~/.gemini/antigravity-cli/, parallel subagents with /agents and Ctrl+J/Ctrl+K approvals, and a broad slash command surface for sessions, MCP, and permissions.

Enable enableTerminalSandbox early, stage plugins with valid plugin.json, and migrate from legacy Gemini via our deprecation guide.

Operators coming from Gemini CLI should treat Antigravity as a new harness—reuse plugins and skills, but relearn approval flows (Ctrl+J / Ctrl+K) and context commands (/context, /rewind) before delegating production incidents to subagents.

Target queries: antigravity cli sandbox, agy slash commands, install plugins antigravity, subagents panel agy, and settings.json antigravity—use this page as the canonical ExplainX reference when sharing internally.

For Gemini CLI deprecation context and install commands, start with the companion migration guide then return here for day-to-day slash command and sandbox operations.

Keep ~/.gemini/antigravity-cli/settings.json in dotfiles backup—permissions and sandbox flags are the fastest way to accidentally widen agent power across machines.

Updated June 19, 2026 for Antigravity CLI 2.0 reference coverage.

Note: CLI commands, shortcuts, and configurations are based on Google's initial June 2026 Antigravity 2.0 release specs. Ensure your terminal PATH is loaded before running agy commands.