Getting Started with Antigravity CLI : Tutorial Series

Welcome to the Antigravity CLI Tutorial Series. Antigravity CLI is the terminal-first interface to work with Antigravity Agents. It can be used for all kinds of tasks ranging from coding to automating repeated tasks.

The Series:

Part 1 : Getting Started (this blog)

Part 2 : Conversations, Conversations, Conversations

Part 3: Agent Skills in Antigravity

Codelab: If you prefer to do a hands-on, step-by-step instructional codelab, go directly to the “Getting Started with Antigravity CLI Codelab”.

Blog Updates

05-Sep-2026 : Updated the tutorial for the latest version of Antigravity CLI (1.1.27) at the time of writing. Added a new section on /plan command.
04-Jun-2026 : Added section on understanding what changes have happened to Antigravity CLI via the agy changelog command. Added a new section on models subcommand introduced in 1.0.5 to get the current list of models supported and how to pass the model to the Antigravity CLI via the --model command-line parameter.
24-May-2026 : Added section on AGY CLI command-line parameters. Updated installation section with agy update command.
23-May-2026 : Updated the installation instructions. Added new sections on /btw command and /context command to visualize context.

Antigravity CLI is part of the Antigravity 2 release. As the documentation states, “It brings the same core agentic capabilities as Antigravity 2.0 — including multi-step reasoning, multi-file editing, tool calling, and conversation history — directly to your terminal.”

Reference: https://antigravity.google/product/antigravity-cli

Here are a few highlights at the time of the initial announcement, in terms of what Antigravity CLI brings to the table:

• Faster Execution: The new CLI is built in Go, making it noticeably snappier and more responsive than its predecessor.
• Asynchronous Workflows: This is a huge productivity boost. Users can now run large-scale tasks (like codebase refactors or deep research) in the background. The CLI will orchestrate the agents without locking up the active terminal session.
• Unified Architecture: The CLI shares the same backend agent harness as the new desktop app, Antigravity 2.0. This means any future improvements to the core agents will instantly apply to the terminal experience.

Installation

The installation is straightforward and binaries are available across major Operating System. I have taken the commands to run in the terminal directly from the installation document:

macOS | Linux

curl -fsSL https://antigravity.google/cli/install.sh | bash

Windows PowerShell

irm https://antigravity.google/cli/install.ps1 | iex

Windows CMD

curl -fsSL https://antigravity.google/cli/install.cmd -o install.cmd && install.cmd && del install.cmd

This should ideally setup and install the Antigravity CLI (agy) in your system and in the Path.

For e.g. on my MacOS , the installer copied and setup the following executable here: /Users/romin/.local/bin/agyand there was an entry made in the profile to add that folder to the path.

# Added by Antigravity CLI installer
export PATH="/Users/romin/.local/bin:$PATH"

In some cases, if the installer is not able to add the binary ( agy to the PATH), it will say so and will let you know in terms of what you need to do to add it to the PATH.

I suggest that we start with a specific folder agy-cli-projects and work through that for the rest of the tutorial.

Create a folder named agy-cli-projects and navigate into that. We will launch Antigravity CLI from that folder. I have created it in my home folder but you can do that based on your preference.

Just check out the version of Antigravity CLI via the following command:

$ agy --version
1.1.27

Updating Antigravity CLI

You can update Antigravity CLI at any time via the agy update command. This checks for newer versions and then downloads and updates your current local installation.

Changelog
It is a good idea to check the changelog to get a sense of the updates that have happened across different versions of Antigravity CLI. Use the agy changelog command for that. A sample (partial) run for the latest update at the time of writing is shown below:

$ agy changelog
1.1.27:
· Added `/model <name> <prompt>`, which runs a single prompt on another model and then returns the session to the model it was using, so you can consult a different model mid-conversation without disturbing your saved default.
· Added a `conversation_title` field to the JSON payload passed to custom status line and window title scripts, so they can show the active conversation's name and pick up renames immediately.
· Added an `agents` list to custom agent Markdown frontmatter, letting an agent declare the subagents it depends on using the same workspace-relative, absolute, and agent-relative path rules as `skills`.
· Improved `/model` to show a `[model]` argument hint as you type, so the command's arguments are discoverable without opening help.
· Improved the `/settings` panel so each Verbosity option explains itself as you highlight it, describing whether tool calls, commands, and thoughts are shown in full or collapsed into a token metrics table.
· Improved the sign-in and Google Cloud setup screens to use the CLI's standard styled key hints, which follow your color scheme and keybindings and drop the navigation hint when only one option is available.
· Changed `/model <name>` to report `Model already set to <name>` when the session is already using that model, instead of reporting a switch that did not happen.
· Fixed tool calls to MCP servers accepting arguments the server's own schema never declared, so an invented parameter is now rejected and corrected instead of being silently dropped.
· Fixed headless runs with `-p` silently skipping tool actions they were not permitted to take, which now end with a notice naming the refused actions and report them as `denied_actions` in the JSON output.
· Fixed `?` in Vim Normal mode opening the shortcuts panel while the prompt already contained text, so character-search and replace operators such as `f?`, `t?`, and `df?` work; `?` still opens shortcuts on an empty prompt.
· Fixed `/model` with no argument doing nothing when run before the session had finished starting up, so it now opens the model picker.
· Fixed print mode (`-p`) exiting before the session finished shutting down, which could drop the run's trailing conversation history before it reached disk.
· Fixed a redundant approval prompt when the agent reads or writes another conversation's artifact files after you have already allowed access to files outside your workspace.

1.1.26:
· Added half-page....

1.1.25:

...
...
1.0.0:
· Initial release of the Antigravity CLI.

Logging into Antigravity CLI

When we launch Antigravity CLI for the first time, it will ask you to login. Launch agy and it should show something similar to this:

Once the login is successful, a few things happen:

First up, it asks you about the color theme that you wish to choose for Antigravity CLI, as shown below. Pick the one that you like.

Next up, you need to accept a few terms of service:

Finally, the most important thing is to give your permission that you trust the folder, as shown below:

Accessing workspace:

/Users/romin/agy-cli-projects

Do you trust the contents of this project?

Antigravity CLI requires permission to read, edit, and execute files here.

> Yes, I trust this folder
  No, exit

  ↑/↓ Navigate · enter Confirm
                                                                                                                                   Gemini 3.5 Flash (High)

You will see this typically in any new folder that you launch the Antigravity CLI on. We will come to more on this later in the series but for now, go ahead and say Yes, I trust this folder.

You are all set now and its waiting for your prompt:

      ▄▀▀▄        Antigravity CLI 1.1.27
     ▀▀▀▀▀▀       <YOUR_ACCOUNT_EMAIL>
    ▀▀▀▀▀▀▀▀      Gemini 3.5 Flash (High)
   ▄▀▀    ▀▀▄     ~/agy-cli-projects
  ▄▀▀      ▀▀▄

───────────────────────────────────────────────────────────
>
───────────────────────────────────────────────────────────
? for shortcuts                     Gemini 3.8 Flash (High)

Antigravity CLI — A few housekeeping commands

Notice that it is using Gemini 3.8 Flash (the latest model at the time of writing) as shown in the bottom right. The first thing ideally is to understand that most of the customization and settings that you need to do are available via the /config or /settingscommand.

Configuration / Settings

Go ahead and invoke the /config command. This will bring up various areas of Antigravity that you can customize based on your preferences. This includes the Color Scheme, Tool permission, telemetry settings and more.

For example, the Color Scheme brings up the following options, from which I can choose my preferred color scheme:

settings.json

The configuration settings need to be stored somewhere right? All of them get stored in ~/.gemini/antigravity-cli/settings.json file. A sample is shown below:

{
       "colorScheme": "dark",
       "model": "Gemini 3.5 Flash (High)",
       "statusLine": {
         "type": "",
         "command": "",
         "enabled": true
       },
       "trustedWorkspaces": [
         "/Users/romin/antigravity-cli-projects",
         "/Users/romin/agy-cli-projects"
       ]
     }

You can notice the colorScheme that I have selected, the model and also various folders from where I have started Antigravity CLI and said yes to trusting the folders.

Note: You can modify the settings.json directly too and restart Antigravity CLI as a best practice to see the changes. But be sure of the settings, else it will display an error at startup. I suggest to use the /settings or /config command in the Antigravity CLI to work with this file.

Tool Permission

An important setting to understand is the Tool Permission and I show the options below. You can get to this via the /config command.

Tool Permission
  > request-review (current)
    proceed-in-sandbox
    always-proceed
    strict

By default, it is set to request-review. Let’s understand this in more detail:

In Antigravity, Tool Permission settings control the balance between security (guarding your host system against unintended changes) and velocity (how autonomously the agent can work without pausing for your input).

request-review (Current Default)
In this mode, the agent is treated as a collaborative partner that checks in before performing any action that could affect your system or project files outside of pre-approved bounds.

How it works: Whenever the agent attempts to run a terminal command, perform a file operation (like writing/deleting), or call an external service where permission hasn’t been pre-approved, the execution pauses. The user is prompted to approve or reject the specific action.

Example:

• The agent needs to install a package using npm install lodash.Instead of running the command immediately, the CLI pauses and shows a prompt as shown below, and you have choice to decide whether to allow it to proceed or so on. It is recommended that you can keep this default setting, so that you get familiar with how your commands are being run.

Requesting permission for: npm install lodash

Do you want to proceed?
> 1. Yes
  2. Yes, and always allow in this conversation for commands that start with 'npm install'
  3. Yes, and always allow for commands that start with 'npm install' (Persist to settings.json)
  4. No

proceed-in-sandbox

This mode allows the agent to execute terminal commands automatically, but within a secure, isolated container. The agent can run commands without prompting you, but those commands are executed in a virtualized sandbox (e.g., a lightweight container). They cannot modify your actual host machine’s filesystem or access your local network.

always-proceed

This is the fully autonomous mode, giving the agent maximum speed and capability. The agent is granted full permission to run commands and write files directly on your host machine. It will never prompt you for confirmation.

Example:
You leave a long-running task running overnight using the /goal command (e.g., “Refactor our styling system to use vanilla CSS and ensure all components build without error”). In this scenario, The agent writes dozens of files, runs npm run build , resolves compiler errors, installs helper packages, and runs git commands entirely on its own. The work completes without ever pausing to wait for your approval. (Use with caution: only use this in trusted, version-controlled repositories).

strict

This is a zero-trust, high-security mode. The agent’s capabilities are restricted to executing read tools. All non-read tools will require the user to be prompted for action.

Set a model

You can use the /model command to select a model that will be used. At the time of writing, this is the list of models shown when you use the /model command:

You can choose any of the models as needed, based on your preference.

You do have an option of setting the model while starting a agy session. You can do that via the agy --model "model_name" command line options. This will then use a specify model for that session. This is very useful if you wish to start the agy session in an autonomous mode i.e. via the --prompt option. If you’d like to know which models are available, you can use the agy models command. Take a look at the command-line options discussed later in this blog.

Antigravity CLI Reference (List of Commands and Shortcuts)

What are the commands and keyboard shorcuts Antigravity CLI. The command as expected /help is your friend. Alternately, you can just type a ? to get this list.

Try it out to see the range of commands available and learn a few shortcuts to navigate the terminal easily.

Here are all 50+ commands available in 1.1.27 at the time of writing. Try out a few if you’d like. We will cover several of them as we go along in the series.

Changelog

Antigravity CLI is likely to undergo rapid changes. We saw that with Gemini CLI earlier, where there were almost daily updates. While we cannot predict the velocity of the releases, its good to know what is changing across the releases via the /changelog command.

Exit Antigravity CLI

This can be done via the /quit command. If you are having difficulty to get to the prompt input, use esc esc to come out where you are.

Shell mode

This is similar to Gemini CLI and you can enter into a Shell mode, such that you can give shell commands without the need to exit Antigravity CLI and come back again to it.

Simply use the ! to go into Shell mode. You will notice that the prompt prefix will change from > to ! as shown below:

You can give commands like ls, pwd and other utilities that you might have too.

Our first coding task

I am going to create a folder inside of agy-cli-projects and start my Antigravity CLI inside of that. I have named the folder bq-release-notes since I am going to create a BigQuery Release Notes Reader application.

Let’s give Antigravity CLI our first task and ask it to build a web application that displays the content of a current RSS feed. Let’s say that I am very much interested in BigQuery Release notes. There is a RSS Feed for it.

I would like a web application in my prefered stack to be build to access this feed and show me the information.

I begin with the following prompt:

Please build a web application for me using Python Flask and plain vanilla HTML, JavaScript and CSS that fetches the BigQuery Release notes from (https://docs.cloud.google.com/feeds/bigquery-release-notes.xml) and shows them to me. A simple refresh button with a spinner is good enough, anytime I’d like to refresh the details. I would also like the ability to take any specific update, select it and then Tweet about it.

The above prompt assumes that I have Python environment on my machine and hence Antigravity CLI will use it behind the scenes. It will prompt you for permissions, make sure that you give it the necessary permissions. For e.g. I got the following message and I got ahead and give it the required permission.

Antigravity CLI goes about doing its work and generating the application. It generates the files (source, html, etc), writes unit test cases, starts the server, validates test cases and once everything looks good, it comes back with the following:

I have built the web application for you using Python Flask and plain vanilla HTML, JavaScript, and CSS.

  ### Key Features Implemented

  1. BigQuery Atom Feed Integration (feed_service.py):
      • Fetches directly from the official feed: https://docs.cloud.google.com/feeds/bigquery-release-notes.xml.
      • Breaks down date entries into individual categorized updates (Feature, Change, Fixed, Security, Deprecated, Announcement, Issue).
      • Converts content into safe structural blocks (paragraphs, links, inline code, lists) so no raw HTML needs to be injected.
  2. Async Refresh with Spinner:
      • A dedicated Refresh button in the navigation header with an animated spinning indicator.
      • Triggers an asynchronous refresh from the feed without reloading the page.
      • Displays the last updated timestamp and real-time status.
  3. Select & Tweet Studio (app.js & style.css):
      • Interactive Selection: Click on any update card (or the "Select to Tweet" button) to highlight it and load it into the Tweet Composer.
      • Smart Draft Generation: Automatically formats the tweet with category emojis, summary, documentation anchor link, and #BigQuery #GoogleCloud hashtags.
      • Format Switcher: Quickly switch between Standard, Concise, and Alert formats.
      • Twitter Character Counter: Displays a live character counter tracking the 280-character limit (properly weighting URLs at 23 characters).
      • 1-Click Post on 𝕏 (Twitter): Launches Twitter Web Intent (https://twitter.com/intent/tweet?text=...) in a safe new tab (noopener,noreferrer).
      • Clipboard Actions: One-click "Copy Tweet" and "Copy Link" buttons with animated toast feedback.
  4. Search & Category Filtering:
      • Search box to filter updates by keyword (e.g. TabFM, JDBC, Preview, Pipelines).
      • Category filter pills with live match counts.
  5. Security & XSS Protection:
      • Vanilla JavaScript client uses zero innerHTML / outerHTML / document.write (100% pure DOM elements using createElement, textContent, and safe link validation).
      • Flask server serves strict Content Security Policy (script-src 'self'), X-Frame-Options: DENY, and X-Content-Type-Options: nosniff.
      • Local binding strictly to 127.0.0.1.

  ──────
  ### Project Structure

  • app.py: Flask application and security header middleware.
  • feed_service.py: Feed retrieval, XML parsing, and tweet generation logic.
  • index.html: Semantic HTML5 layout with sidebar Tweet Composer.
  • style.css: Google Cloud styled design, responsive layout, and spinner animations.
  • app.js: Vanilla JavaScript client logic and safe DOM manipulation.
  • test_app.py: Unit and integration test suite.
  • requirements.txt: Pinned dependencies.
  • README.md: Documentation.
  ──────
  ### How to Run

  1. Activate the Virtual Environment & Install Dependencies:
    cd /Users/romin/agy-cli-projects/bq-release-notes
    source venv/bin/activate
    pip install -r requirements.txt

  2. Start the Flask Application:
    python3 app.py

  3. Open in your browser:
  Navigate to http://127.0.0.1:5050
  4. Run Tests:
    python3 -m unittest test_app.py -v

I ask it to start the server for me and give me the url to test via the following prompt:

> Start the server for me and give me the url to test out the application

It does the needful and displays the following message:

 The server is up and running!

  ### 🌐 Access the Application

  Click the link below or open it in your browser:

  👉 http://127.0.0.1:5050
  ──────
  ### What You Can Try Out:

  1. Browse Updates: Release notes are grouped chronologically with badges indicating update types (Feature, Change, Fixed, Security, etc.).
  2. Refresh with Spinner: Click the Refresh button in the top right to watch the animated spinner fetch the latest feed items without reloading the page.
  3. Select & Tweet:
      • Click on any release note card or tap "Select to Tweet".
      • The Tweet Composer on the right will auto-populate with the formatted summary, official documentation link, and hashtags (#BigQuery #GoogleCloud).
      • Switch format styles (Standard, Concise, Alert) or edit the text.
      • Click "Post on 𝕏 (Twitter)" to launch Twitter with your pre-filled tweet, or use "Copy" to copy it to your clipboard.
  4. Search & Filter: Type keywords like TabFM, JDBC, or Preview into the search box or filter by category pills.

The application looks good:

I can go on now with new features, some changes, etc. But we can stop for now. The idea was to demonstrate and check out what it can do with simple requirements.

Planning the task first

In the aboe task, you noticed that Antigravity CLI went ahead with the generating of the application code and testing. While that might be fine in some scenarios, you might want to see a plan first, ok that and then ask Antigravity to go ahead. This can also give you the opportunity to make any changes to the plan, before you ask Antigravity to go ahead with the generation of the application files.

Get Romin Irani’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

You can do that with the /plan command. Let’s see that in action and also understand about Artifacts.

First up, create another folder famous-quotes inside of the agy-cli-projects folder. Launch Antigravity CLI from that.

Then give the following prompt that has the /plan command. Notice that we are asking Antigravity in simple terms, to plan out the activity and let us know what it is going to do.

/plan a web application using plain vanilla javascript, html and Python flask to display a random quote from 100 well-known quotes. I should be able to search based on the author of
  the quote or some categories.

Antigravity CLI comes back to us with the following:

  I have created the detailed implementation plan for the Famous Quotes web application:

  👉 famous_quotes_plan.md

  ### Key Highlights

  • 100 Curated Quotes: Formatted with verified authors and diverse categories (Inspiration, Philosophy, Wisdom, Courage, Life, Humor, etc.).
  • Python Flask Backend: RESTful API endpoints for random quotes, search, category/author aggregation, and security response headers.
  • Pure Vanilla JavaScript & Modern CSS: Safe DOM manipulation (createElement, textContent, replaceChildren), real-time search and filter controls, animated random quote card, and
  copy-to-clipboard interactions.
  • Automated Testing & Security Checks: unittest suite covering API behaviors, edge cases, and security headers.

  Please review the plan and click Proceed or let me know if you would like any changes!
                                                                                                                                                           1 artifact · /artifact to review

In the bottom right corner, you will also see 1 artifact /artifact to review.

Artifacts are files that Antigravity produces and which you can review to understand more. You can list, approve and do things with artifacts. In this scenario, Antigravity has created the famous_quotes_plan.md artifact and we can view it. If you give the /artifact command, it provides the following:

You can now use the arrow / tab keys to either open / approve / reject the file.

If you choose open , I see solid details on the plan:

This way you can view the artifact, suggest changes and eventually approve it as needed.

I go ahead and approve it. This gets Antigravity going on the next task in the workflow i.e. generating the application for us.

Eventually, just like the previous step, once task is complete, I can check the application that it has generated and engage with it, to make more changes / enhancements as needed.

Once the task is completed, Antigravity provides the following output:

 The Famous Quotes web application has been built, tested, and verified.

  ### Summary of What Was Built

  • Curated 100 Quotes Dataset: quotes.json contains exactly 100 famous quotes across 10 categories (Inspiration, Philosophy, Wisdom, Courage, Life, Success, Humor, Science, Leadership,
  Perseverance) and 72 distinct authors.
  • Python Flask Backend: app.py exposes REST API endpoints for fetching random quotes (/api/quotes/random), multi-criteria searching/filtering (/api/quotes), and category/author
  aggregation (/api/categories, /api/authors), with strict security headers (CSP, X-Frame-Options: DENY, X-Content-Type-Options: nosniff).
  • Safe Vanilla JavaScript: app.js implements dynamic DOM updates strictly via safe methods (createElement, textContent, replaceChildren), clipboard copying with non-blocking toast
  notifications, and debounced real-time search.
  • Semantic HTML & Modern CSS: index.html and styles.css deliver a responsive UI with smooth card fade animations and mobile support.
  • Automated Tests: test_app.py contains 15 passing test cases covering dataset integrity, API search/filter parameters, random quote selection, and security headers.

  ### Detailed Walkthrough

  Please see the complete walkthrough and security report in 👉 walkthrough.md.

  ### How to Run

    cd /Users/romin/agy-cli-projects/famous-quotes
    source .venv/bin/activate
    python3 app.py

  Open http://127.0.0.1:5001 in your browser to explore the application.

Notice that it generated a new artifact too i.e. walkthrough.md that provides information on what was done and how to test things out. I can view this artifact too via the /artifact command.

Partial output of the walkthrough.md file is shown below:

Here is the final web application:

Our first non-coding task

Go to https://github.com/rominirani/gemini-cli-codelab-projects and check out the folder invoice-processing folder that has several invoices in the form of images.

Let’s create a new folder inside of agy-cli-projects named invoice-processing. Download the four files into that folder and launch Antigravity CLI from there. You can take a peek into any of the invoices. One of the files is shown below (its an image):

You can use the Shell mode ( ! ) and then use the ls command to verify if you see the four invoice files there.

● ! ls
  ⎿  inv1.png
     inv2.png
     inv3.png
     inv4.png

Now give the following prompt:

Use @inv1.png and extract the following invoice information in the form of a table: Invoice No, Invoice Date, Invoice Sent By, Due Date, Due Amount.

Notice that you can use @ and you will see a list of files that will come up and you can choose from them. In short, I am asking Antigravity CLI to analyze this image file and extract relevant information of the invoice that I am interested in.

I get the following output:

  Analyzing Invoice Contents
  Here is the extracted invoice information from inv1.png:                                                                                      
                                                                                                                                                      
   Invoice No                  │ Invoice Date                │ Invoice Sent By             │ Due Date                    │ Due Amount
  ─────────────────────────────┼─────────────────────────────┼─────────────────────────────┼─────────────────────────────┼────────────────────────────
    01234                      │ 11.02.2030                  │ Adeline Palmerston          │ 11.03.2030                  │ $440

I can even ask it to simply go through the folder and extract information from all the invoices present in the folder. Here is the prompt:

The current folder contains a list of invoice files in Image format. Go through all the files in this folder and extract the following invoice information in the form of a table: Invoice No, Invoice Date, Invoice Sent By, Due Date, Due Amount.

Here is the output:

Here is the extracted invoice information from all four files in the folder:                                                                        
                                                                                                                                                      
   File                │ Invoice No           │ Invoice Date       │ Invoice Sent By                        │ Due Date           │ Due Amount
  ─────────────────────┼──────────────────────┼────────────────────┼────────────────────────────────────────┼────────────────────┼────────────────────
   inv1.png      │  01234               │ 11.02.2030         │ Adeline Palmerston                     │ 11.03.2030         │ $440.00
   inv2.png      │  US-001              │ 11/02/2019         │ East Repair Inc.                       │ 26/02/2019         │ $154.06
   inv3.png      │  123456789  (P.O. #) │ November 23, 2023  │ A Company With A Clever Name (docubee) │ November 30, 2023  │ $42.30
   inv4.png      │  [123456]            │ 12/9/2019          │ Company Name                           │ 1/8/2020           │ $971.56

I could even go a bit different and ask it to highlight all invoices that are having payment date that has passed.

list all files with .png extension in this folder. Extract the invoice information from it by reading them locally and display it in a table format containing the following column headers: : Invoice No, Invoice Date, Invoice Sent By, Due Date, Due Amount. Add a column at the end of the table that shows a red cross emoji in case the due date is in the past.

Here’s the output:

I suggest that you go ahead and try out all kinds of tasks that are non-coding related. Analyzing some files, organizing them and so on.

Schedule an instruction

You can use the /schedule command to automate recurring tasks or set one-time reminders.

Let’s see how things work, when we just give the /schedule command. I get the following helpful reply:

/schedule

  Would you like to set up a recurring cron schedule or a one-time timer?                                                                             
                                                                                                                                                      
  Please specify:                                                                                                                                     
                                                                                                                                                      
  1. The timing: E.g., a duration in seconds (up to 900) or a cron expression (e.g.,  */5 * * * * ).                                                  
  2. The prompt: What task or reminder you want to run when it fires.                 

I go ahead and ask it to do a one-minute timer and then remind me that there is a meeting:

> A one-time timer

  For how many seconds (up to 900 seconds/15 minutes) should the timer run, and what reminder message (prompt) should be triggered when it fires?     

────────────────────────────────────────────────────────────
> In 1 minute, remind me that there is a meeting

○ Schedule() (ctrl+o to expand)

  I have set a 1-minute timer for you. I will notify you as soon as it fires.       

Now, you can get back to your work with Antigravity CLI. Once the timer is up, it should fire and let you know. And yes , in a minute, I got this message:

 ⏰ Reminder: There is a meeting starting now!     

Here are some examples:

• A Pomodoro Timer that you can set and then get back to work. It will then remind you that time is up.
  /schedule duration=”600" prompt=”Remind me that the current task time is over”
• In 3 minutes, run the following to check if migrations are successfully applied:
  /schedule duration=”180" prompt=”Run ‘npm run db:status’ to verify if all migrations were successfully applied.”
• Here is one to check the logs in some time and see if there are any new errors:
  /schedule duration=”600" prompt=”Inspect the logs folder and check if there are any new error entries or uncaught exceptions.”

You can also do a recurring (Cron expression) schedule to do a task. For e.g. do something at 9:00 AM every monday, or every 12 hours, etc. Here are some examples (I recommend that you substitute it with your commands, utilities and specific instructions):

Standup Prep (Every weekday morning at 9:00 AM)

/schedule cron="0 9 * * 1–5" prompt="Generate a bulleted summary of all git commits and file modifications made in the workspace in the last 24 hours."

End-of-Day Code Quality Check (Every weekday at 5:00 PM)

/schedule cron="0 17 * * 1–5" prompt="Run 'npm test' and 'npm run lint' and report any test failures or code quality warnings."

Local Server Health Check (Every 10 minutes)

/schedule cron="*/10 * * * *" prompt="Check if the server running on http://localhost:3000 is still up and returning a 200 OK response."

Hourly Folder Scan (Every hour)

/schedule cron="0 * * * *" prompt="Scan the input directory for any new raw files, process them (put your rules here), and move them to the 'archive' folder."

Weekly Dependency Update Audit (Every Friday at 4:00 PM)

/schedule cron="0 16 * * 5" prompt="Run a security audit on project dependencies (e.g., 'npm audit' or 'pip-audit') and report any critical vulnerabilities."

As an example, I setup a one-time 10 minute timer and then another recurring timer than runs every 10 mins.

Once scheduled, I can interact in natural language with Antigravity CLI to find what tasks are running in the background. Just give a prompt like list my active tasks

> list my active tasks

● ManageTask(You have 2 background task(s) currently running:) (ctrl+o to expand)

  Here are your currently active background tasks:                                                                                                    
                                                                                                                                                      
  1.  task-35                                                                                                                                         
      • Type: One-time Timer (600 seconds)                                                                                                            
      • Prompt: "Remind the user that the current task time is over."                                                                                 
      • Start Time: 2026-05-22T20:26:11 (Local time)                                                                                                  
  2.  task-43                                                                                                                                         
      • Type: Recurring Cron ( */10 * * * *  — every 10 minutes)                                                                                      
      • Prompt: "Check if the server running on http://localhost:3000 is still up and returning a 200 OK response."                                   
      • Start Time: 2026-05-22T20:33:29 (Local time) 

You can now interact with it to even remove a task and so on.

We have a lot more to cover

We have just scratched the surface at this point with Antigravity CLI. There are several commands to still try out, in addition to key things like configuring plugins, MCP Servers, skills, background tasks, parallel tasks, context management and more. At this point, you should feel confident to navigate across Antigravity CLI and try things out.

Examine the Context

You can visualize your context at any point in time via the /context command. A sample is shown below:

By the Way (btw)

This is actually a command and a pretty useful one too. If you main agent is busy with some long running task, you can use the /btw command to ask it a side question. This does not interrupt the currently running task.

The best way to try this would be by giving the Antigravity CLI a long running task like generating some application and then while it is busy, just give /btw <some task> and see it in action.

For example, the Agent is in the midst of refactoring the code and you would like to know about a specific git command. Give this instruction:

/btw What is the git command to list branches sorted by last commit date?

or something like this:

/btw what does exit status code 137 typically indicate?

Here are few more things to know about /btw :

• Parallel & Non-Interruptive: If the agent is currently busy running a long build script or refactoring several files in the workspace, typing /btw does not pause, abort, or delay that process. The main agent task continues running in the background.

• Ephemeral UI: The output is rendered in a temporary overlay panel (similar to a modal) directly in the terminal interface. When you close the panel (by pressing Enter or Esc ), the response vanishes.

• No Side-Effects (Read-Only context): To ensure speed and safety, /btw operates in a read-only mode. It has full read access to the files and conversation state, but it cannot execute tools (e.g., writing files, running bash commands, or scheduling tasks).

• Token Efficiency: The prompt and response of a /btw query are not appended to the primary conversation history. This prevents casual questions from inflating the conversation context window (context bloat).

Understanding Command-line parameters of Antigravity CLI

When we launched Antigravity CLI, we simply used agy to launch it. It uses several defaults in terms of what it needs to do and then shows you the terminal in which you can proceed to give commands.

In this section, we shall look at a few command line options, that are available to use, while launching Antigravity CLI at the command line.

If you can’t wait, you can get the current list of command line parameters/options available to you by using the agy --help , agy help, or agy -h command. This shows the following list at the time of writing:

$ agy --help
Usage of agy:
  --add-dir                       Add a directory to the workspace (repeatable) (default [])
  --agent                         Agent for the current CLI session
  -c                              Short alias for --continue
  --continue                      Continue the most recent conversation
  --conversation                  Resume a previous conversation by ID
  --dangerously-skip-permissions  Auto-approve all tool permission requests without prompting
  --disable-slash-commands        Disable slash command and skill expansion in print mode
  --effort                        Reasoning effort for the current CLI session (low|medium|high)
  -i                              Short alias for --prompt-interactive
  --input-format                  Input format for print mode (text, stream-json). stream-json reads one NDJSON message per line from stdin and runs a turn for each; it requires --output-format stream-json (default text)
  --json-schema                   Optional JSON schema string or path to a schema file to enforce structured output (for stream-json, only applicable to the final result)
  --log-file                      Override CLI log file path
  --mode                          Set the agent execution mode for this session (accept-edits, plan)
  --model                         Model for the current CLI session
  --new-project                   Create a new project for this session
  --output-format                 Output format for print mode (text, json, stream-json) (default text)
  -p                              Short alias for --print
  --print                         Run a single prompt non-interactively and print the response
  --print-timeout                 Timeout for print mode wait (default 5m0s)
  --project                       Project ID or project name for the current CLI session
  --prompt                        Alias for --print
  --prompt-interactive            Run an initial prompt interactively and continue the session
  --sandbox                       Run in a sandbox with terminal restrictions enabled

Available subcommands:
  agent           List available agents
  agents          List available agents
  changelog       Show changelog and release notes
  help            Show help for subcommands
  install         Configure environment paths and shell settings
  mcp             Manage MCP servers (add, remove, list, enable, disable)
  mic-serve       Serve this machine's microphone to a CLI on another host
  models          List available models
  plugin          Manage plugins (install, uninstall, list, enable, disable)
  plugins         Alias for plugin
  remote-control  Manage the remote-control background daemon (start, status, stop)
  update          Update CLI

So far we have launched Antigravity CLI and have been using it in interactive mode. If you’d like Antigravity CLI to just take your prompt, execute it and give back the result., then go for the non-interactive mode. This is done via the --prompt parameter or via -p or --print parameter.

This can be very useful in scenarios where you want to integrate Antigravity CLI in automated pipelines or schedule something at a specific time, without the need for any human interface.

agy -p "What is the command line syntax for doing a GET call to myhost.com via curl"

This might be a good way to get some quick answers but do keep in mind that there is be no scope to continue the conversation with follow up questions.

If you like to live dangerously (I do not), then you can look for a very aptly named parameter called --dangerously-skip-permissions.

Launch Antigravity CLI via the following command:

agy --dangerously-skip-permissions

Then give the following prompt. Check that it did not ask me for any write file permissions.

> get the latest news and write it in a file called news.txt. Then create another file that contains the summary of that file.

● ListDir(/Users/romin/agy-cli-projects) 
● WebSearch(latest world news May 24 2026 news headlines) (ctrl+o to expand)

▸ Thought for 2s, 95 tokens
  Processing News Information

● Create(/Users/romin/agy-cli-projects/news.txt) 
● Create(/Users/romin/agy-cli-projects/summary.txt) (ctrl+o to expand)

  I have fetched the latest world news headlines and created the requested files in your workspace:                                                                   
                                                                                                                                                                      
  1. news.txt: Contains the detailed news headlines for today (May 24, 2026), including topics on geopolitics (U.S.-Iran negotiations, Ukraine conflict), U.S.  
  security incidents, the Ebola outbreak in Central Africa, and the passing of NASCAR champion Kyle Busch.                                                            
  2. summary.txt: Contains a concise, structured summary of the major categories covered in the news file.                                                         

● ! ls
     news.txt
     summary.txt

This mode can be useful in scenarios where things are local and in your control but still be prepared for surprises and hence use it with care.

Specifying a model to use for the session

You can use the --model parameter to tell Antigravity CLI to use a specific model during its session only. This is very useful for the autonomous mode that we discussed, where you would like to launch several agy sessions and use specific models for specific tasks.

But first, you need to know which models are available for Antigravity CLI. You can do that via the models subcommand as shown below:

$ agy models
Gemini 3.5 Flash (Medium)
Gemini 3.5 Flash (High)
Gemini 3.5 Flash (Low)
Gemini 3.1 Pro (Low)
Gemini 3.1 Pro (High)
Claude Sonnet 4.6 (Thinking)
Claude Opus 4.6 (Thinking)

You can use any of these model names to specify the model to be used for the session. You can do that via the --model command shown below:

$ agy --model "Claude Opus 4.6 (Thinking)"

Once Antigravity CLI launches, you can check either via the /model command about the specific model that you asked it to use or look at the bottom right that shows the model used for the session. An example is shown below:

More command-line options

We will cover c , continue , conversation parameters in a separate part in this series, but will keep adding more information on command line parameters here, as Antigravity CLI takes shape. If you’d like to learn more about Conversations, check out Part 2.

Conclusion

Thanks for reading this tutorial. This is just an initial introduction to help maximum number of users get started with Antigravity CLI. Check out my other tutorials on various products in the Antigravity ecosystem.