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.
Welcome to Antigravity CLI Tutorial.
The Series:
Part 1 : Getting Started(this blog)
Part 2 : Conversations, Conversations, Conversations
Codelab : If you prefer to do a hands-on, step-by-step instructional codelab, go directly to the “Getting Started with Antigravity CLI Codelab”.
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.
If you are looking for Gemini CLI, this is not the same as Antigravity CLI. Gemini CLI is the open-source version terminal interface that lets you use the power of the Gemini model for your tasks via natural language. It has its own ecosystem of Extensions and I have written a tutorial series on that earlier.
Blog Updates
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.
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. For e.g. on another machine, I saw the following output, where it will clearly tell you what to do, to add it to the PATH.
% curl -fsSL https://antigravity.google/cli/install.sh | bash
⠋ Detecting system environment...
✓ Platform detected: darwin_arm64
⠋ Querying release repository...
✓ Latest available version: 1.0.1
⠋ Downloading release package...
✓ Download complete and checksum verified.
⠋ Extracting binary from archive...
⠋ Configuring shell environment...
I0523 11:44:14.012088 76528 installer.go:27] Running Antigravity CLI setup...
Warning: /Users/neilirani/.local/bin is not present in your active PATH.
To use the 'agy' CLI globally, please manually add it to your shell profile:
echo 'export PATH="/Users/neilirani/.local/bin:$PATH"' >> ~/.zshrc && source ~/.zshrc
✅ Antigravity CLI binary placed successfully at /Users/neilirani/.local/bin/agy
Note: The binary is installed, but it is not in your active PATH. Please follow the instructions above to add it, then restart your terminal session.
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. 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.0.2
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.0.5:
· Added `--model` to set model when launching CLI. Also a new `models` subcommand to list available models.
· Added `/permissions` command which allows to add/edit/remove permissions rules for each of the three configs above directly inside the CLI.
· Allowed opening the Artifact Review panel (shortcut `ctrl+r`) while answering pending questions or tool permission confirmations, preserving your current progress when toggling back.
· Fixed a bug that metadata was written in the current directory as opposed to `~/.gemini/antigravity-cli/cache` when running using `-p`.
· Improved statusline layout by merging active tip and artifact status on a single line and truncating with ellipsis on narrow terminals to prevent collisions.
· Improved customization support by allowing directories in the customization manager to be passed as workspace directories, enabling correct trajectory metadata population and `/add-dir` support.
· Added support for `url` in `mcp_config.json` to configure MCP servers directly via a URL.
· Improved `/resume` performance: optimized lazy loading of conversation details, filtered out empty conversations, and added support for scanning SQLite database files (`.db` and `.db-wal`).
· Improved autocomplete: tab completion for slash commands now resolves to the matched alias instead of the primary command name (e.g., `/se` autocompletes to `/settings` instead of `/config`).
· Integrated the permissioning system with the rest of Antigravity. CLI permissions now merges project level permissions, permissions from user settings shared with Antigravity, and permissions from the CLI `settings.json`.
1.0.4:
· Added SQLite (.db) conversation support and will be CLI’s conversation format. Fixed a bug when importing SQLite conversation from Antigravity 2.0 to CLI.
· Added LaTeX math rendering, enabling the CLI to display beautiful mathematical formulas directly in the terminal viewport. Set `AGY_CLI_DISABLE_LATEX` environment variable to turn off LaTeX rendering globally if desired.
· Decoupled project discovery from local `.antigravitycli` workspace directories. The CLI now stores workspace-to-project mappings in a centralized `~/.gemini/antigravity-cli/cache/projects.json` file, eliminating repository clutter and speeding up project discovery to a single-map lookup.
· Resolved sporadic and permanent UI hangs caused by a stateful callback streamer race condition during network drops or extremely fast agent steps.
· Collapses all newlines and consecutive whitespaces in conversation previews and titles before rendering list items, preventing visual UI layout breaks in the picker rows.
· Styled the separator space between the line number column and diff content to match the text blocks, ensuring background highlights stretch seamlessly across the viewport width in tool outputs and `/diff` details.
· Resolved inconsistent behavior where selecting skill-derived slash commands from autocompletion suggestions cleared the input without executing. Autocompleted skill commands are now correctly submitted to the backend.
...
1.0.3: ...
1.0.2: ...
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:
▄▀▀▄
▀▀▀▀▀▀
▀▀▀▀▀▀▀▀
▄▀▀ ▀▀▄
▄▀▀ ▀▀▄
Welcome to the Antigravity CLI. You are currently not signed in.
Select login method:
> 1. Google OAuth
2. Use a Google Cloud project
[Use arrow keys to navigate, Enter to select]
Use your personal account for now. Choose 1. Google OAuth and press Enter. This will launch a browser and you can login with your Google Account. On successful authentication and authorization, you are asked to copy a code. Please come back into the Antigravity CLI terminal and paste the code.
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.0.1
▀▀▀▀▀▀ <YOUR_ACCOUNT_EMAIL>
▀▀▀▀▀▀▀▀ Gemini 3.5 Flash (High)
▄▀▀ ▀▀▄ ~/agy-cli-projects
▄▀▀ ▀▀▄
───────────────────────────────────────────────────────────
>
───────────────────────────────────────────────────────────
? for shortcuts Gemini 3.5 Flash (Medium)
Antigravity CLI — A few housekeeping commands
Notice that it is using Gemini 3.5 Flash 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 that given that the documentation is sparse at the moment, 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:
Switch Model
> Gemini 3.5 Flash (High) (current)
Gemini 3.5 Flash (Medium)
Gemini 3.1 Pro (High)
Gemini 3.1 Pro (Low)
Claude Sonnet 4.6 (Thinking)
Claude Opus 4.6 (Thinking)
GPT-OSS 120B (Medium)
Keyboard: ↑/↓ Navigate enter Select esc Go Back
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. 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 34 commands available in 1.0.1 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. We are already seeing a good list of changes between the current version 1.0.1 vs 1.0.0 as shown below:
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.
Whenever you exit, you will see the command that is needed to continue the conversation. As an example, this is what I received. If you do that, you can resume the conversation and will have an entire list of prompts that you gave. Just use Arrows Keys (up and down) in the prompt to see the history.
Resume: agy --conversation=bbb2048c-7de6-4dd5-ba7e-8b0c27d46b95 (or -c)
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.
This results in the following response from Antigravity CLI:
I will start by exploring the workspace to see if there is an existing structure or if this is a brand new project.
● ListDir(/Users/romin/agy-cli-projects/bq-release-notes) (ctrl+o to expand)
I will read the BigQuery release notes XML feed to understand its structure (Atom/RSS elements, entry/item elements, namespaces, dates, titles, content) so that we can parse it
correctly in the Python Flask backend.
● ReadURL(https://docs.cloud.google.com/feeds/bigquery-release-notes.xml) (ctrl+o to expand)
I will view the fetched feed content saved locally to understand its format and structure.
● Read(/Users/romin/.gemini/antigravity-cli/brain/116191af-e6ea-4ba5-aa23-62f995bd068a/.system_generated/steps/6/content.md) (ctrl+o to expand)
▸ Thought for 2s, 2.3k tokens
Analyzing XML Feed Structure
I will write the implementation plan detailing the architecture, design aesthetic, components, and verification steps for the BigQuery Release Notes Web Application. This plan will be
written to the artifacts directory.
● Create(/Users/romin/.gemini/antigravity-cli/brain/116191af-e6ea-4ba5-aa23-62f995bd068a/implementation_plan.md) (ctrl+o to expand)
I have created the implementation_plan.md to outline the design and architecture of the BigQuery Release Notes Web Application.
Please review the plan, especially the approach for the Twitter Composer & Preview Card, and let me know if you approve or if there are any adjustments you'd like to make!
1 artifact · /artifact to review
Remember that behind the scenes, you get the same Antigravity harness and if you are familiar with Antigravity, you can see that it has created an artifact (file) for us to view. Artifacts are how the Antigravity CLI keeps us in the loop with an implementation plan, list of tasks that it is working on, verifiable outputs and more.
In this case, if you notice, it says and I quote “I will write the implementation plan detailing the architecture, design aesthetic, components, and verification steps for the BigQuery Release Notes Web Application. This plan will be written to the artifacts directory.”
Once it does that, it says “ I have created the implementation_plan.md to outline the design and architecture of the BigQuery Release Notes Web Application. Please review the plan, especially the approach for the Twitter Composer & Preview Card, and let me know if you approve or if there are any adjustments you’d like to make!”
You can see that it also mentions in the bottom right, that there is 1 Artifact to review and in this case, it is the implementation_plan.md.
Now remember, this is all in the terminal, so we will have to use that and see how it goes. It’s pretty neat if you ask me.
Give the command /artifact. This will display the following:
This clearly shows that there is a file implementation_plan.md created and I can use the arrow keys to open, approve, reject and so on. This should be familiar to those who have used earlier or even the recent version of Antigravity (the non-CLI app).
On opening it, I can see the entire artifact i.e. Implementation plan.
Just Escape and come back to the prompt, here you can approve it , if you’d like:
Alternately, you can reject or even converse with some changes or modifications that you like. For e.g. we will go full vibe mode and say approve.
This kicks off the next set of steps, where it will start the implementation i.e. creating files, running a few commans, etc. You will be prompted to approve and give permission to execute, as required.
In my case, I gave it the approval to create the Python virtual environment, install the dependencies via requirements.txt and so on.
In the background, it has also created a task.md file as part of the tasks that it has to do based on the implementation plan and it ticks off the individual tasks, as it completes them. You will just have to pay attention to the thought process and the tasks as it completes them. It makes for a fascinating experience.
Finally I get the message that I wanted to see:
I have successfully completed the implementation of the BigQuery Release Pulse web application!
The application dev server is up and running locally at http://127.0.0.1:5000.
Please refer to the walkthrough.md for details on the architectural implementation, the features we delivered, and verified test scenarios.
I also see that there are several artifacts as expected (Implementation Plan, Task List and a Walkthrough document)
Action required (3 left)
› task.md open
walkthrough.md
□ new implementation_plan.md
Media · 1 items (enter to expand)
If I look at the Task artifact, I get the following:
task.md
> 1 Tasks
2
3 [✓] Setup dependencies and environment
4 [✓] Implement backend Flask application ( app.py )
5 [✓] Implement frontend HTML structure ( templates/index.html )
6 [✓] Implement frontend CSS styling ( static/css/style.css )
7 [✓] Implement frontend JS logic ( static/js/app.js )
8 [✓] Verify local execution and manual test scenarios
9 [✓] Create walkthrough documentation ( walkthrough.md )
Good work.
I check the application in my browser and here it is. It looks great with a lot of features already thought out:
Here’s my Tweet feature too:
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.
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. Later parts of the tutorial will cover them.
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 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 [])
-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
-i Short alias for --prompt-interactive
--log-file Override CLI log file path
--model Model for the current CLI session
-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)
--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:
changelog Show changelog and release notes
help Show help for subcommands
install Configure environment paths and shell settings
models List available models
plugin Manage plugins (install, uninstall, list, enable, disable)
plugins Alias for plugin
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.
Transitioning from Gemini CLI to Antigravity CLI
If you have been using Gemini CLI, here are a few things that you need to understand.
First up, you are not going to lose any of favourite workflows. Antigravity CLI to a large extent retains most of the features that you have been used to from Gemini CLI. Since it is early days yet, it is expected that the product team will use this time to probably get more parity based on user feedback. When it comes to Antigravity CLI, note that at the start of the article, we highlighted its key points about parallel execution, shared backend harness of Antigravity 2.0 and faster execution times.
If you have been using a personal account with Gemini CLI, here are a few dates and events to keep in mind:
- June 18, 2026: This is the hard cutoff for individual and free-tier users. On this date, the Gemini CLI and Gemini Code Assist IDE extensions will stop serving requests.
Please read the following blogs for more details on what will work or not, post June 18 2026 , especially if you are using a personal account.
An important update: Transitioning Gemini CLI to Antigravity CLI
It is also important to understand a few changes from Gemini CLI, especially when it comes to configuration files that you were used to editing while tweaking and setting things up. This is critical since you might be having Extentions, MCP Servers, Skills and Context files that you were using with Gemini CLI.
Check out this section of the document on Migrating , that helps you understand what Antigravity CLI can directly import and use and a few key differences.
Conclusion
Thanks for reading this tutorial. This is just an initial introduction to help maximum number of users get started with Antigravity CLI. I will cover more parts in detail, as we move along.
Top comments (0)