Antigravity CLI 1.1.15: Agentic Terminal Guide

Google Antigravity CLI 1.1.15: What Changed and How to Build Safer Terminal Agents

Google Antigravity CLI is moving quickly from a Gemini CLI successor into a shared terminal surface for Google's broader agent harness. The latest public release, version 1.1.15, shipped on August 19, 2026, with stream-json input, plugin-declared rules, better model-picker behavior, improved enterprise authentication, and fixes for streamed Unicode text and media handling.

That makes this a useful moment to evaluate Antigravity CLI as an engineering runtime—not just another coding assistant. The central question is whether your team needs a lightweight terminal UI, a multi-agent background workflow, or a controlled automation surface that can be driven by another process.

Quick answer

Use Antigravity CLI when you want a terminal-first agent that shares its core harness with Antigravity 2.0, supports skills, hooks, plugins, subagents, MCP servers, and background work, and can now consume newline-delimited JSON for long-lived drivers. Do not treat it as an unattended production deployer by default: command permissions, workspace boundaries, credentials, MCP access, and output validation still belong in your own control plane.

The August 19 release is especially relevant for developers building wrappers, CI helpers, evaluation runners, or internal agent workbenches. Its --input-format stream-json mode can keep one conversation open while a driver sends one JSON prompt per line.

What the August 19 release adds

The official 1.1.15 release notes describe several changes that matter to agent builders:

• Stream JSON input: print mode can read newline-delimited JSON prompts from standard input and run each message in one conversation.
• Explicit rules in agents: Markdown-defined agents can name rule files directly with a rules: key instead of inheriting an entire rule tree.
• Plugin-declared rules: a plugin can ship a top-level rules.json, alongside its skills and other customization files.
• Better tool visibility: the spinner now identifies the tool call currently running, which helps when a turn contains several background operations.
• Credential and billing fixes: personal-account keyring restoration and enterprise Application Default Credentials receive several reliability fixes.
• Terminal and media fixes: model-picker rendering, non-ASCII streaming, nested artifacts, and WAV MIME normalization are improved.

These are not headline model improvements. They are harness improvements. For an agent system, that distinction matters: the harness determines how work is started, resumed, constrained, inspected, and recovered.

The architecture: one harness, multiple surfaces

Google introduced Antigravity CLI in May as a lightweight terminal alternative to Antigravity 2.0. Google's description says the CLI and desktop app share the same agent harness and settings, while the CLI is optimized for speed and low overhead. Google has also positioned the Antigravity SDK and Managed Agents in the Gemini API as additional ways to use related infrastructure.

Figure 1 — A practical control-flow model for Antigravity CLI. The CLI provides the terminal surface; your wrapper should remain responsible for policy, approvals, and validation.

The shared-harness design is useful because improvements can reach more than one product surface. It also creates a risk: settings and capabilities that are convenient on a laptop may be too broad for CI. Treat the CLI as an execution component inside a larger boundary, not as the boundary itself.

Why stream-json matters for agent infrastructure

Interactive terminal UIs are designed for people. A driver process needs deterministic input and output, explicit turn boundaries, and a way to keep context alive without repeatedly starting a fresh process. Newline-delimited JSON is a better fit for that job than scraping terminal text.

A minimal conceptual driver looks like this:

1{"prompt":"Inspect the test failures and group them by root cause"}
2{"prompt":"Now propose the smallest safe patch; do not edit files yet"}
3{"prompt":"Run the targeted tests and report only verified results"}

The release notes confirm the input mode and the single-conversation behavior. They do not, by themselves, guarantee that every downstream output field is a stable API contract. A production wrapper should therefore:

1. Pin the CLI version instead of depending on latest.
2. Validate each input record before writing it to the process.
3. Capture stdout and stderr separately.
4. Apply a timeout and kill policy to stuck turns.
5. Persist the conversation identifier and driver state outside the CLI.
6. Treat model output as untrusted until tests, schemas, or human review validate it.

For a deeper treatment of making coding agents reliable through explicit state, tools, approvals, and recovery, see the guide to harness engineering for AI coding agents.

Antigravity CLI versus the desktop app

The two surfaces share a harness, but they solve different interaction problems. The desktop application emphasizes asynchronous task management, artifacts, project organization, visual review, scheduled tasks, and dynamic subagents. The CLI emphasizes a low-overhead terminal loop and automation-friendly invocation.

The table is a workflow comparison, not a performance benchmark. Google and TechCrunch report the product positioning and capabilities, but neither source establishes a universal latency or quality advantage for one surface. Measure your own traces.

Migrating from Gemini CLI without copying old assumptions

Google's transition announcement says Antigravity CLI preserves important Gemini CLI concepts including Agent Skills, Hooks, Subagents, and Extensions, now represented as Antigravity plugins. The same announcement also warns that there was not one-to-one feature parity at launch and gives a consumer transition timeline.

The safe migration pattern is incremental:

Inventory the old integration

List the skills, extensions, MCP servers, hooks, environment variables, model aliases, and filesystem assumptions used by your Gemini CLI workflows. Separate essential behavior from convenience configuration.

Rebuild the smallest path

Start with one read-only task. Give it a narrow workspace, a test repository, and no production credentials. Confirm that the agent can discover the intended skills and MCP servers without inheriting unrelated personal configuration.

Add write access behind review

Only after the read-only path is predictable should you permit edits. Require a diff, run tests in a clean environment, and preserve a human approval step for changes that affect deployment, data migrations, authentication, or billing.

Test failure recovery

Interrupt the process, expire a credential, make an MCP server unavailable, and feed malformed input. A migration is incomplete if it works only on the happy path.

If your workflow needs an external tool gateway, compare this approach with the MCP and agent-stack architecture guide and the GitHub Copilot agentic workflow update.

Security and permission boundaries

Antigravity CLI can load tools, skills, plugins, MCP servers, rules, and credentials. That flexibility is useful—and exactly why a wrapper should define a security policy before it starts an agent.

At minimum, enforce these boundaries:

• Filesystem: use a temporary or dedicated workspace; do not expose home directories or unrelated repositories.
• Network: allow-list MCP endpoints and outbound services; log tool calls and response sizes.
• Credentials: inject short-lived, task-specific credentials rather than a developer's full environment.
• Commands: classify destructive commands and require explicit approval.
• Artifacts: scan generated files and patches before they enter a trusted branch.
• Secrets: prevent prompts, logs, and artifacts from receiving environment dumps or secret-bearing files.
• Supply chain: pin plugins and review their rules, skills, hooks, and MCP configuration as code.

The 1.1.14 release notes are a useful reminder of this surface area: that release included MCP client metadata support, read-only behavior for certain outside-workspace access, and fixes for malformed MCP configuration affecting other servers. These are operational details, not reasons to assume the system is secure automatically.

Teams already using an agent sandbox can connect the CLI to that boundary rather than granting it broad host access. The AI sandboxing and execution guide is a useful related reference when designing that layer.

A practical evaluation plan

Do not evaluate Antigravity CLI with one impressive demo. Use a small corpus of real tasks:

1. Repository navigation: locate a bug across several packages without editing.
2. Patch generation: implement a bounded change and produce a reviewable diff.
3. Test repair: fix a failing test without weakening assertions.
4. Tool use: call one approved MCP server and reject an unapproved one.
5. Long-running work: send multiple stream-json prompts through one conversation.
6. Recovery: resume after interruption and verify that state is not silently lost.

Record success rate, human correction time, tool-call errors, token use, wall-clock time, and the percentage of tasks that require a restart. Compare against your current CLI agent, not an abstract benchmark.

Common failure modes

The driver assumes terminal text is an API

Interactive output can change with terminal width, theme, or release. Use the documented input mode and isolate machine-readable output from presentation output.

A plugin inherits too much context

Broad inherited skills and rules can make an agent appear capable while quietly expanding its authority. Prefer explicit rule files and a reviewed plugin manifest.

One conversation becomes a hidden state store

A persistent conversation is convenient for multi-step work, but it can also retain stale assumptions. Bound the task, checkpoint state externally, and restart when the context no longer represents the current repository.

“The agent ran tests” is accepted without evidence

Capture exit codes, test names, logs, and the working tree diff. A natural-language claim is not a test result.

Migration is treated as a rename

Gemini CLI and Antigravity CLI share concepts, but the product and backend transition changes lifecycle, permissions, and integration assumptions. Re-test every extension and MCP server.

FAQ

Is Antigravity CLI a replacement for Gemini CLI?

For consumer workflows, Google is directing users toward Antigravity CLI and Antigravity 2.0. Enterprise access to Gemini CLI and Gemini Code Assist is described separately in Google's transition announcement, so organizations should follow their license and deployment documentation rather than assume the consumer timeline applies to them.

Does Antigravity CLI run multiple agents?

Google describes asynchronous workflows and a shared harness capable of multi-agent work. The exact orchestration behavior depends on the task, configuration, tools, and product surface. Validate concurrency and cancellation in your own environment.

Can I use MCP servers with Antigravity CLI?

The release history and Google transition documentation reference MCP-related workflows and configuration. Use an allow-list, pin server versions, and test malformed or unavailable servers before trusting the integration.

Should I use it in CI?

It can be evaluated in CI for bounded, non-production tasks. Start with read-only analysis and isolated test repositories. Do not give an agent unrestricted deployment credentials merely because it can operate from a terminal.

Bottom line

Antigravity CLI 1.1.15 is a meaningful infrastructure release because it improves the boundary between a human-facing terminal agent and a machine-driven workflow. Stream-json input, explicit rules, plugin-declared configuration, and more legible tool execution make the CLI easier to place inside a driver or evaluation harness.

The right adoption strategy is verification-first: pin the version, minimize permissions, keep state and approvals outside the agent, and measure real tasks. Antigravity's shared-harness direction is promising for teams that want one agent foundation across terminal, desktop, API, and enterprise surfaces—but shared infrastructure does not remove the need for local policy.

Sources and visual credits

• Antigravity CLI 1.1.15 release — official release notes and changes.
• Google Antigravity CLI announcement — official product positioning and shared-harness details.
• Google's Gemini CLI transition announcement — migration scope, preserved concepts, and consumer/enterprise timeline.
• Google I/O 2026 developer highlights — official ecosystem overview.
• TechCrunch coverage — independent launch reporting.

Visual credits: Figure 1 is an original Mermaid diagram by the author, based on the official Antigravity CLI, Google Developers Blog, and Google I/O descriptions. The comparison table is an original editorial synthesis; it is not a vendor benchmark.