DEV Community: Romin Irani

Google Cloud Platform Technology Nuggets — May 16–31, 2026

Romin Irani — Wed, 03 Jun 2026 06:19:11 +0000

Welcome to the May 16–31, 2026 edition of Google Cloud Platform Technology Nuggets. The nuggets are also available on YouTube.

Infographic for the post generated by NotebookLM

AI and Machine Learning

If you are looking to stay updated on the latest Google Cloud AI tools, you should bookmark this link that covers updates made across the months.

There has been a spate of announcements at Google Cloud Next 2026 in April and Google I/O held in May introduced several other releases too, that included:

Gemini 3.5 Flash models
Gemini Omni (any output from any input, starting with video)
Google Antigravity in its new version
Managed Agents on Agent Platform

Check out the post that highlights these announcements in detail.

Google Cloud has introduced the general availability of Nano Banana 2 (Gemini 3.1 Flash Image) and Nano Banana Pro (Gemini 3 Pro Image) on the Gemini Enterprise Agent Platform and the Gemini API. These enterprise-grade models allow developers to integrate image generation and editing capabilities directly into their applications and workflows.

Long-running agent workflows is where the industry is moving. But how to manage and operate them reliably and efficiently. Google believes you can use Agent Executor, an open-source runtime standard designed for executing, resuming, and deploying distributed AI agents. The key technical capabilities of this standard include:

Durable execution to automatically resume progress via event logs and snapshotting after human-in-the-loop steps or outages
Secure isolation through sandboxes to safely execute code and manage multi-tenant workloads
Session consistency using a single-writer architecture to prevent state corruption
Connection recovery to allow disconnected clients to reconnect and backfill missed responses
Trajectory branching to let agents test alternative decision paths using checkpoints.

Check out the blog post for more details.

Looking to deploy and optimize large language models on mobile devices, take a look at new benchmarking and debugging capabilities within the Google AI Edge Portal. The platform allows developers to run automated testing across a fleet of over 120 Android device types to evaluate performance across CPU and GPU backends using the LiteRT-LM format. Check out the blog post.

Data Analytics

Data Agent Kit is an open-source collection of data engineering and data science skills, Model Context Protocol (MCP) tools, and plugins designed to connect development environments like VS Code and various CLIs with enterprise data. The kit provides pre-codified skills for tasks like query optimization, data validation, and troubleshooting, alongside MCP tools that create secure connections to platforms like BigQuery, AlloyDB, and Google Cloud Storage without requiring manual pipeline code. Check it out.

Remote Model Context Protocol (MCP) Server for AlloyDB is now in General Availability. The Remote MCP Server for AlloyDB runs on fully-managed Google Cloud infrastructure and exposes an HTTP endpoint that connects your AI applications to your data. It is integrated with the Agent Registry, supports fine-grained authorization, allows agents to not just run queries but also manage instances and more. Check out the blog post that highlights the features and a demo of how an agent has been integrate to work with AlloyDB.

Connected Sheets, which provides a direct connection between Google Sheets and BigQuery, has been there for a while. Instead of exporting data as CSVs, which causes version control and security risks, this feature allows users to perform ad-hoc analysis, modeling, and reporting on live data without writing SQL. Check out a blog post, which gives you a quick overview of Connected Sheets, walk through real-world use cases, and show you how to perform enterprise-grade data analysis using BigQuery directly in Google Sheets.

Databases

AlloyDB has got a significant upgrade to its High Availability (HA) architecture: Hot Standby. With the new architecture, the standby node continuously streams and applies write-ahead logs (WAL) from the primary node. This change allows the system to detect failures and promote the standby node within 30 seconds, dropping the average failover time to approximately 15 seconds. Furthermore, because the standby node constantly replays logs, its memory caches stay warm, allowing the database to maintain its transaction-per-second rate immediately after a failover without any performance brownouts. This feature is automatically rolled out to new instances on PostgreSQL 18 at no additional cost, with earlier versions receiving support in the following months. For more details, check out the blog post.

Developers & Practitioners

You are a developer working on building out Agents on Google technologies. How do you know which one to pick to develop these agents, since there are quite a few ranging from no-code to heavily code-driven frameworks. The article is an excellent way to step back and look at the existing landscape today to develop agents on Google Cloud, with options ranging from low code (Agent Studio) to ADK 2.0. Included in the spectrum is the recently announced Managed Agents API, which allows you to define agentic behavior and let Google Cloud handle the heavy lifting, acting as an agent-as-a-service with nothing to manage.

It is given that we need to secure our credentials, especially API Keys that may have been configured to have access to several Google Cloud services and could be a problem, if misused. But what are the recommended best practices to manage and secure your API Keys. This post goes into the detail while highlighting services like Secret Manager to manage/rotate keys, regular audits and more.

Reducing friction for developers trying out developer tools from Google and eventually deploying them on Google, has traditionally faced the common struggle of folks signing up for billing first. With a newly announced deeper integration between Google AI Studio and Google Cloud, you can now vibe code with Google AI Studio with a possible persistent layer backed by Firestore and deploy two applications on Google Cloud Run, without the need of a credit card. Check this out.

Gemini Live Agent Challenge has announced the winners and key highlights from the contest that asked developers to integrate real-time multimodal capabilities using the Gemini Live API, the Agent Development Kit (ADK), and Google Cloud infrastructure. The global challenge resulted in projects across three main categories:

Live Agent (Voice)
Creative Storyteller (Audio / Visual)
UI Navigator (Gesture-driven interactions)

Notable winners included ORION, a voice-directed surgical co-pilot for robotic surgery; drone-copilot, which replaces manual joysticks with natural language voice commands for navigation and autonomous visual inspections; and Moonwalk, a hands-free desktop assistant that automates workflows by controlling the keyboard and mouse through voice.

AI agent conversations usually go back and forth with a series of questions and usually the interactions end up with just text data and interpreting the intent and extracting data can be not just challenging but more efficient in terms of number of interactions. What if a set of questions that the Agent wants to ask of the user, is converted into a simple UI with the right kind of input controls to select the data from. For e.g. a dropdown, a few checkboxes, etc. Enter A2UI (Agent to UI) Protocol, an open protocol for agent-driven user interfaces and a great example of how this protocol can be embedded into the front-door Gemini Enterprise application is demonstrated in this blog post.

Customers

One of the interesting blog posts that I look forward to each month is one in which we can learn what customers have been building with Google Cloud. For the month of May, there were interesting things that they built. Some of which include:

Glance automated its short-form video extraction pipeline by combining Google Cloud Speech-to-Text v2, Gemini 2.5 Flash, the Google Vision API, Samurai object tracking, OpenCV, and MoviePy.
Urban Outfitters migrated its 11TB Oracle database to AlloyDB for PostgreSQL to power its IBM Sterling OMS, deploying two read replicas to lower data latency for reporting and analytics.
Movix engineered an agentic AI solution for dental lab quality control using the Gemini Enterprise Agent Platform alongside Cloud Run with L4 GPUs and Compute Engine VMs.

Check out the post for more of what cool things that customers built.

Containers and Kubernetes

Google Kubernetes Engine (GKE) Agent Sandbox helps you manage isolated, stateful, and single-replica workloads on GKE. It is optimized for use cases like AI agent runtimes, where untrusted, LLM-generated code must be executed in a secure and performant environment. The GKE Agent Sandbox is now generally available and there is a new introduction too, Agent Substrate. This open source project introduces a minimal control plane that moves agents on and off ready compute capacity in real-time while integrating data locality directly into its scheduler to minimize overhead. . Check out the blog post.

Security and Identity

If you are looking to protect your systems from high-speed, automated cybersecurity threats, Google Cloud has introduced Google AI Threat Defense, an autonomous platform built on a four-step framework: Prepare, Scan and Prioritize, Remediate, and Monitor. The system reduces attack surface exposure through Wiz, which maps your live environment and uses an AI penetration testing agent to validate exploitable pathways. When vulnerabilities are discovered, the platform incorporates Mandiant expertise for response planning while CodeMender automatically generates fixes, analyzes library dependencies, and creates verification tests directly inside the developer’s integrated development environment or command-line interface. Check out the blog post for more details.

The second Cloud CISO Perspectives for May 2026 is out. If you are looking to build an AI-ready security program for the public sector, this article outlines a structured, 12-month roadmap designed to manage complex systems and reduce operational toil. The plan is organized across five core workload domains: executive alignment, process optimization, talent augmentation, posture elevation, and advanced governance.

Infrastructure and Networking

There have been several architectural updates to Google’s global and data center networks designed to handle the specific traffic patterns and scale required for AI training and inference workloads. The new Virgo Network serves as a flat, two-layer scale-out data center fabric that connects up to 134,000 eighth-generation TPU chips, delivering increased bandwidth, lower latency, and autonomous reliability features like automated hang and straggler detection to isolate faulty instances. Read more here.

Given the kind of infrastructure that Google runs, it should be interesting to learn about how they ensure that any optimizations that they introduce to their infrastrcture takes place safely. In fact they run a fleet-wide, machine-level A/B experimentation framework. Instead of testing at the application level, Google enables changes on individual machines across a balanced 1% subset of the fleet to capture system-wide effects for core components like libraries, compilers, kernels, and cluster management systems. Check out the details here.

DevOps and SRE

SRE AI is an initiative that integrates agentic AI into Site Reliability Engineering. This includes deploying autonomous AI agents across the entire software development lifecycle. These agents assist in reliability design by creating and updating playbooks, use models like TimesFM for anomaly detection and alert enrichment, and orchestrate incident management by summarizing communications and drafting postmortems. For more details, check out the blog post.

Application Development

Google Cloud has introduced App-centric maintenance visibility within Unified Maintenance to shift planned maintenance tracking from an infrastructure-focused view to a business-oriented view. By integrating directly with App Hub, Unified Maintenance automatically aggregates the maintenance schedules of registered resources (GKE clusters, GCE VMs, or AlloyDB instances) into a single dashboard centered around the application as the primary unit of management. To use this feature, teams need to enable the Maintenance API and configure application boundaries in the Google Cloud Console. For more details, check out the blog post.

Continuing on Application Development, we now have a public preview of AppLifecycle Manager Feature Flags (ALM FF). This service decouples feature releases from code deployments, allowing teams to ship code with new features disabled by default and use a toggle as an instant kill switch if issues arise. Built on the open-source OpenFeature standard and the flagd evaluation engine, ALM FF uses Common Expression Language (CEL) to enable targeted rollouts, such as percentage-based traffic ramping or precise allowlisting for specific internal teams and testers. Check out the blog post.

Learn about Google Cloud

If you have been working with traditional transactional databases and are looking to transition enterprise data from static reports to autonomous systems, Google Cloud outlines a structural evolution across five technical scenarios to manage security, costs, and accuracy. These five scenarios are:

Scenario 1: The Static API Contract, which uses pre-written, parameterized SQL queries for deterministic performance.
Scenario 2: Custom Agent with SQL Generation, where an LLM translates natural language into queries using schema metadata.
Scenario 3: Conversational Analytics, which uses a platform-native engine grounded in verified query libraries to enforce business logic.
Scenario 4: Managed MCP Tools introduces the open-source Model Context Protocol (MCP) to decouple the reasoning layer from tool execution via a managed BigQuery server. This helps to scale across different systems.
Scenario 5: Custom Hosted MCP Servers gives engineers full control to build specialized, multi-source tools on infrastructure like Cloud Run, allowing for programmatic governance and custom data abstraction.

Check out the blog post that provides detailed guidance, queries and more.

Write for Google Cloud Medium publication

If you would like to share your Google Cloud expertise with your fellow practitioners, consider becoming an author for Google Cloud Medium publication. Reach out to me via comments and/or fill out thisform and I’ll be happy to add you as a writer.

Stay in Touch

Have questions, comments, or other feedback on this newsletter? Please send Feedback.

If any of your peers are interested in receiving this newsletter, send them theSubscribe link.

Getting Started with Antigravity 2.0

Romin Irani — Mon, 25 May 2026 15:35:16 +0000

Welcome to the tutorial on Antigravity 2.0, Google’s command center that helps in managing AI agents that execute complex knowledge and coding tasks.

Article updates:

May 27, 2026 : Codelab update

May 26, 2026: Updated section on Antigravity Skills

May 25, 2026 : Initial version

Codelab

If you’d prefer to directly just do a codelab instead of going through the blog, you can go here directly. In the codelab, you will learn how to use Google Antigravity to design, build, and deploy a serverless application to Google Cloud. We will build a serverless and event-driven document pipeline that ingests files from Google Cloud Storage (GCS), processes them using Cloud Run and Gemini, and streams their metadata into BigQuery. If you have never used Antigravity 2 before, it is suggested that you go through the basics here in this blog and then do the codelab.

Antigravity is an agentic development platform that is designed to help you develop in this era of agents. As the document states “Antigravity 2.0 serves as your AI agents’ central command center, providing a unified platform to launch, monitor, and orchestrate their activities. Unlike its predecessor, the Agent Manager, Antigravity 2.0 is a standalone application that functions independently of an IDE.”

Antigravity 2.0 was announced on May 19 at Google I/O, the flagship Google developer event. You can read about the announcement here.

Google Antigravity

Antigravity 2.0 is a major iteration over Antigravity 1.x.x version, which was first announced in November 2025.

When the original Google Antigravity IDE was launched, it was an interesting time to demonstrate that an “agent-first” graphical interface would work well for software development. If we read the announcement blog post, it is highlighted that as the platform evolved, a few key points surfaced up:

Beyond Coding: Agentic capabilities are rapidly expanding from traditional coding into general knowledge work. Tying an agent interface exclusively to a code-heavy IDE was not just daunting but a key friction-point. As a developer, we may not entirely agree with this, but there is a point to be made here. There is also a good set of folks who strongly believe that we may never have to touch any code in the future.
Separation of Concerns: By untangling the agent-first surface from traditional IDE concepts (like repositories), Antigravity could be rebuilt from the ground up to be more intuitive for a wider range of tasks.
Co-optimization: A standalone app allows the product, the agent harness, and the underlying Gemini models to be co-optimized independently of an IDE environment.

The result in front of us now is Antigravity 2.0 : a completely standalone desktop application designed for a purely agent-optimized experience. This is not to say that there is no Antigravity IDE or the ability to use an IDE, as we shall see later.

The New Antigravity Product Suite

With the 2.0 launch, Antigravity is no longer just an Agent Manager integrated with an IDE. It is now a complete ecosystem of products designed for the agent-first era:

Antigravity 2.0 Desktop App: The flagship standalone application for macOS, Linux, and Windows. This is your command center to manage multiple local agents in parallel, run scheduled tasks and more. Unlike its predecessor, the Agent Manager, Antigravity 2.0 is a standalone application that functions independently of an IDE.
Antigravity IDE: The original fully-featured, agentic IDE remains available (and recommended for developers!). It comes with the agent manager, artifacts, and a deep understanding of your codebase. In the future, the standalone Agent Manager will be removed from the IDE, turning it into a purely agent-powered development environment.
Antigravity CLI: A command-line interface for terminal-based agent interactions. This will not be covered in this tutorial.
Antigravity SDK & API: Tools for developers to programmatically integrate Antigravity into their own systems. This will not be covered in this tutorial.

(Optional Reading) Comparing it to first version of Antigravity

In the first version, we had a single product Antigravity that had the following 3 key components, all integrated and working closely together, through the Agent Manager was the command center.

Agent Manager : This is the command center, from where you launch a new conversation with an Agent. The Agent Manager managed the tasks for you and generated artifacts (plans, walkthrough) and as needed, source code.
Editor : An integrated and full-blown IDE that you could switch through from the Agent Manager itself and view the source code, interact with it, continue your conversation with the Agent and more.
Browser : This was an interesting component and it was a browser instance that the Agent manager controlled and launched to work with web sites, interact with it, control it, extract data from it and more.

Installing Antigravity 2.0

The equation has changed with Antigravity 2.0 and we now have a suite of products, each one of them available separately and which need to be individually downloaded and installed.

For this tutorial, we are recommending a certain sequence of installation and will not be using all the products under the Antigravity 2.0 umbrella. We will be looking at two possibilities while setting up Antigravity 2.0 : one is if you are starting from scratch (new) and the other, if you have an exisiting Antigravit 1.x.x version installed. Pick any of the options.

If you are new to Antigravity 2.0

Navigate to the Google Antigravity download page.
Download the Antigravity 2.0 standalone application for your operating system (macOS, Linux, or Windows).

Run the installer. It shows the following screen:

Click on Open Antigravity.

Select a Theme that you like:

Antigravity 2.0 comes with a set of plugins that work with various Google Developer Tools. These plugins install a set of skills that helps Antigravity to work with various developer tools of Google. Shown is a list of plugins that you can optionally choose to install.

Finally click on Finish. You should see an interface of Antigravity that looks like the following:

We will get to the interface in a while but we are all set for the moment.

Install Antigravity IDE

Navigate to the Google Antigravity download page.

Download the Antigravity IDE standalone application for your operating system (macOS, Linux, or Windows).
Go ahead with the installation and ensure that you are able to log in.

If you have Antigravity IDE (v1.x.x) installed

Simply wait for your next application update.
During the update, the application will automatically upgrade to Antigravity 2.0.
You will be prompted with an option to keep the Antigravity IDE alongside 2.0. It is highly recommended that developers choose to keep both.
You will see two icons in your dock: Antigravity 2.0 (white background) and Antigravity IDE (black grid background).

Reference : https://antigravity.google/blog/introducing-google-antigravity-2-0

Antigravity 2.0 Main Interface

Let’s focus first on using Antigravity 2.0. I am assuming that you have completed the installation as discussed earlier and are ready.

Ideally, you should see a screen that looks like this:

We will get to the Settings option in the lower left corner, as we go along this tutorial and on a need basis.

What are Projects?

Before we jump into the various aspects of the interface here, let’s understand the concept of Projects first in Antigravity. This is key because if you notice the interface in the right pane, it clearly says Select Project and Antigravity 2.0 uses a Project-centric approach to ensure the agents has access to the right files, tools, permissions and more. This will get clearer as we get along.

A Project as per the documentation is “ configuration of folders defining the environment and the scope of your agent. Instead of forcing an agent to operate within a single folder, a project can work with one folder or multiple folders (e.g., a frontend and a backend repo), providing your agents with all of the context required for your codebase. All projects have their own isolated agent settings , allowing you to customize different projects’ security settings independently.”

Read the above statement, slowly and carefully. Previously Antigravity was limited to a workspace, which is tightly coupled to a single local repository. Now we can define a Project and then add one or more folders that make up the project, so that Antigravity agent will have access to the full context and yet you have the flexibility of organizing your folders/files in a way you want.

There is a lot more to it, but let’s take our first steps.

In my home folder on my local machine, I have created a folder named $HOME/agy2-projects/my-first-project . I suggest you do something like that so that you have an initial empty folder to work with. Note that it need not be an empty folder.

We are now going to create our first project in Antigravity 2.0 by defining what folders constitute the project. In our initial case here, it will be just one folder i.e. $HOME/agy2-projects/my-first-project.

Click on Select Project → New Project as shown below:

As expected it asks you to Select folder(s) as shown below:

Click on Add Folder and navigate to select the specific folder i.e. $HOME/agy2-projects/my-first-project

You can still add more folders to the Project, as you can notice (via Add Folder ), but for now, we are fine with this and we can click on the Create button.

This brings up a very interesting dialog as shown below and this is the key to what was mentioned earlier i.e. “ All projects have their own isolated agent settings , allowing you to customize different projects’ security settings independently.”

In simple words, each project inherits permissions around reviewing artifacts, tools allowed, MCP Server configuration from a global configuration that is available via Settings in the main interface. However, you can set individually these permissions and more per project, thereby getting a lot more flexibility and keeping the context and tools lean and mean for your specific project.

Even if you do not click on the Open Settings button here, you can always go to the main Settings and specific to your project, tweak these permissions.

We will see that in a while since that would be the preferred way to keep coming back to your Project to tweak its individual settings, instead of just at creation time. For now, let’s say Hi to our wonderful agent by clicking on Start first conversation. Once you do that, you will see the following screen and I have highlighted our first project that now appears both in the list of projects on the left and currently as the project in which the Agent will work when you give it messages via the Chat Interface. Notice that you can select the Model, pass additional context via the + sign or @ or / actions and so on.

Let’s greet our Agent with a message and it responds accordingly.

I have another request to get me the news and it does a good job.

Now, let’s break down a few more things.

Conversations

What we have done here is that in our Project ( my-first-project), we started a conversation thread and currently there is a series of messages (user message and agent responses) that are present in the thread.

You will see that this conversation thread remains a single one and it appears on the left side grouped under the project.

Now, let’s do something interesting and give a name to this conversation thread. Let’s call it conv-introduction.

To do that Click on the three vertical dots, next to the conversation. It will show you 3 options. Choose the Rename action.

Give the value conv-introduction or if you’d like to do it your way, any name that makes sense to you.

Now, if you’d like to have a completely new conversation in the project, click the + sign next to the project as shown below.

That’s it. You are into a totally new conversation. Let’s ask it some sports news from across the world. Note that we are still in the my-first-project.

This gives me some news around the sports world and you can notice that now we have two conversation threads in the same project.

I will rename this conversation to conv-sportsnews as per the steps provided earlier.

If you’d like to see all the conversations that have happened so far, you can visit the Conversation History option in the top left as shown below:

At any point in time, you have the option of having a new conversation either in the current project or a new project via the New Conversation option at the top.

Hope that helps you understand how to create projects (add folders to it), start a conversation within a project, rename conversations, switch between them, see the conversation history and more.

One final thing

Where does Antigravity 2.0 persist all of this conversations and threads within it. Let’s take a quick look at that.

To solidy our understanding, a conversation is an isolated work session or execution thread identified by a unique Conversation ID (e.g., 3b4a1d20–3968–4ed2–90b3–00eea3060b02).

Assuming that you have created a Project in Antigravity, had a conversation or two, go and take a look $HOME/.gemini/antigravity folder or ~/.gemini/antigravity folder. So inside of this directory, you will find the following:

brain/ : Contains subdirectories for each conversation (using their Conversation ID) containing:

— .system_generated/logs/ : Every conversation preserves a history of interactions (user requests, agent responses, tool calls, and system messages) serialized as JSON Lines (JSONL) transcripts under

$HOME/.gemini/antigravity/brain//.system_generated/logs/ .

— Artifacts: Each conversation has its own storage directory

( $HOME/.gemini/antigravity/brain// ) where structured markdown documents like the implementation_plan.md , task.md , and walkthrough.md are saved and updated. You may not have these files immediately at this moment, unless you have asked it to do some planning or code generation, etc.

I suggest you take a look into one of the transcript.jsonl files in the /brain//.system_generated/logs/ folder and see the interactions between the user and agent that captures all your messages, responses, metadata and more.

Project Settings

Now let’s get back to the Project Settings that we earlier talked about. As mentioned, when you create a Project in Antigravity, it inherits default Permissions, which you can overrride specifically if you’d like.

How do you get to these Project Settings? For a specific project you can click on the settings gear icon next to each project in the project list shown in the left navigation bar.

This will lead you to the specific Project (i.e. my-first-project) settings as shown below:

Notice first the left side where under Projects, the my-first-project is selected. If there were more projects, these would be visible under this list too and you can easily select any of the projects and tweak their settings as needed.

Now, let’s focus on the right side i.e. the Project settings shown for my-first-project. You will notice that it has the single folder that we had added to this project. You can add more folders from here too.

I suggest that you first go through the entire list and see the flexibility now provided to help you change a ton of settings as per your project customization requirements.

These include:

Security Preset: You can determine if you’d like all terminal commands and file accesses to be reviewed first by you before the agent can perform actions.
Agent Behaviour: In case of artifacts generated, for example the implementation_plan.md , where you would like to review before asking the agent to go ahead and execute the plan.
Various Local Permissions i.e. file paths allowed for access, which URLs are allowed or blocked for the Agent, etc.
You can even configure which specific MCP Tools are allowed for this Project. This is quite useful to prevent all globally configured MCP Servers to be made available to the Agent in this project.

Note: At any point in time, you can go to the settings for Antigravity or even Projects settings via the main settings option in the Antigravity interface.

Use Cases

Let’s move now to generate a complete web application. The web application that we are going to create is a site which provides information on a 1-day technical event, which has talks across the day by multiple speakers.

I am going to create a new Project (that points to a new folder). You can create new project via the options shown below or even from a new conversation:

Then give the prompt given below:

I would like to generate a website that is a 1-day technical conference informational site.
The website should have the following functionality:
1. A home page that shows the current date, location, schedule and time table.
2. The 1-day event is a list of 8 talks in total.
3. Each talk has 1 or 2 max. speakers.
4. A talk has a ID, Title, Speakers, Category (1 or 2), Description and time of the talk.
5. Each speaker has a First Name, Last Name and LinkedIn url.
6. Allow for users to search by category, speaker, title.
7. Give a lunch break of 60 minutes.
8. Use dummy data for events and speakers, come up with a schedule, the event is about Google Cloud Technologies.
9. Tech Stack: Python and Flask framework on server side. Front-end is basic HTML, CSS and JavaScript.
10. Test out the site on your own for all functionality and provide a detailed README on how to setup, run and make any further changes.
11. Launch the web application for me to review.

Please plan it out first.

The Agent takes off and comes back with an implementation plan. This is the first time that probably you might be seeing this but this is one of the Artifacts produced by Antigravity and if you have used an earlier version of Antigravity, this would be familiar.

Before you get eager and click on the Proceed button, do make a note that you can look at any of the artifacts produced by Antigravity by toggling the Auxilliary Pane shown in the top right corner.

If you’ve got sharp eyes, you might say what’s that Install IDE thing next to it. More on that later.

If you toggle the Auxilliary Pane, you see the following output:

You can click on the Implementation Plan to see the details, as shown below:

For now, we are ok with the plan and simply click on the Proceed button to move forward.

Now, as it goes to work, it creates another artifact i.e. Task Plan and other files. You can see all of that in the Auxilliary Pane as shown below:

A Task Plan is quite cool and gives you a step by step task list that Agent is going through as per the implementation plan. As it completes the task, it even marks it as complete. A sample execution is shown below:

During this course, please pay attention to the Agent. It will ask you for several permissions to create folders, Python environments, run scripts and more. Since we have the permissions set to review, you will have to ok them all.

Finally, its completed all the good stuff and shown me the final output:

Its also created a nice Walkthrough guide.

Keep in mind that for each of the artifacts, you might see a small comments icon. Click on that and feel free to give your comments and submit it to the Agent with changes that you might want. You can keep iterating in that fashion.

You can also see the source code files that have been generated and submit your comments/changes as you see fit.

For e.g. here is the list of source code files that it generated:

Let’s click on the app.py file. You can comment on any of the lines in the code as needed and submit it back to the agent.

It has also started a task i.e. the Web Server is started on port 5001. I visit the url in the browser and here’s a nice looking event website that I wanted.

I can stop the running task, once I am done with reviewing the website.

Note: While we are only covering this use case here, I plan to keep adding to this section.

Slash Commands

There are some interesting slash / commands available in Antigravity 2.0. In your conversation chat interface, if you type / , you should see the commands as shown below:

Consider the /browser command. It is an explicit command now to launch it and ask it to do something. It requires Google Chrome and permission in Google Chrome to start a debugging session.

This spawns up a browser sub-agent that attempts to launch a debugging session with Chrome and asks you for permission first:

Once you allow it, it asks for permissions as needed, for e.g.

And then it got me the details:

The /schedule command is useful if you’d like to setup recurring or one-off tasks for the agent to execute at fixed intervals or on a schedule (e.g. 9:00 AM on Monday, Wednesday). At the same time, you are provided the same facility to do this via the user interface and that is covered in the Scheduling Commands section. Please refer to that.

We will cover /goal and /grill-me commands once I create better examples.

Scheduling Commands

You can use the Schedule option in the main interface to automate recurring tasks or set one-time reminders in your specific projects.

Let’s create a Daily task that reminds me of my daily 5 PM meeting. Click on New and fill out the details as shown below:

Click on Add Scheduled Task and then will add the task to the list of scheduled tasks as shown below:

Let me add another one that reminds me every 20 mins to take a break:

I have two scheduled tasks now, as shown below:

You can disable / delete any of the tasks via the options given. Remember that I have used basic prompts but your prompts could be detailed, could be invoking tools (talking to external systems) and doing a lot more serious work behind the scenes on a regular interval, based on your requirements.

MCP Servers

The Model Context Protocol (MCP) has emerged as the standard to help connect agents to external systems. They play a key role in ensuring that the Agent remains grounded in terms of your data and integration.

Antigravity supports MCP Servers, both local and remote. Dazbo (Darren Lester) has written an excellent article in covering not just MCP Server configuration but even setting up Agent Skills in both Antigravity CLI and Antigravity. Check out the article:

Configuring MCP Servers and Skills for Antigravity CLI and IDE

The MCP Servers that you want to configure should go in $HOME/.gemini/config/mcp_config.json file.

Configuring an MCP Server

If you have been working with existing remote MCP Servers, you can simply add the details into the $HOME/.gemini/config/mcp_config.json file. Here is my sample $HOME/.gemini/config/mcp_config.json file that contains my settings for 6 fully-managed MCP Servers on Google Cloud.

Supported products | Google Cloud MCP servers | Google Cloud Documentation

As a side note, if you’d like to get started with fully-managed MCP Servers on Google Cloud, check out my tutorial here.

Tutorial : Getting Started with Google MCP Services

Here is my mcp_config.json file:

{
  "mcpServers": {
      "maps-grounding-lite-mcp": {
        "serverUrl": "https://mapstools.googleapis.com/mcp",
        "headers": {
          "X-Goog-Api-Key": "GOOGLE_MAPS_KEY"
        }
      },
      "developer-knowledge-mcp": {
        "serverUrl": "https://developerknowledge.googleapis.com/mcp",
        "headers": {
          "X-Goog-Api-Key": "DEVELOPER_KNOWLEDGE_API_KEY"
        }
      },
      "bigquery-mcp": {
        "serverURL": "https://bigquery.googleapis.com/mcp",
        "authProviderType": "google_credentials",
        "oauth": {
          "scopes": [
            "https://www.googleapis.com/auth/cloud-platform"
          ]
        },
        "timeout": 30000,
        "headers": {
          "x-goog-user-project": "GOOGLE_CLOUD_PROJECT_ID"
        }
      },
      "logging-mcp": {
        "serverURL": "https://logging.googleapis.com/mcp",
        "authProviderType": "google_credentials",
        "oauth": {
          "scopes": [
            "https://www.googleapis.com/auth/logging.read"
          ]
        },
        "timeout": 30000,
        "headers": {
          "x-goog-user-project": "GOOGLE_CLOUD_PROJECT_ID"
        }
      },
      "cloudrun-mcp": {
        "serverURL": "https://run.googleapis.com/mcp",
        "authProviderType": "google_credentials",
        "oauth": {
          "scopes": [
            "https://www.googleapis.com/auth/run"
          ]
        },
        "timeout": 30000,
        "headers": {
          "x-goog-user-project": "GOOGLE_CLOUD_PROJECT_ID"
        }
      },
      "firestore-mcp": {
        "serverURL": "https://firestore.googleapis.com/mcp",
        "authProviderType": "google_credentials",
        "oauth": {
          "scopes": [
            "https://www.googleapis.com/auth/cloud-platform.read-only"
          ]
        },
        "timeout": 30000,
        "headers": {
          "x-goog-user-project": "GOOGLE_CLOUD_PROJECT_ID"
        }
      } 
  }
}

Once you have added your remote MCP Servers in here and saved the file, you can go to MCP Servers section in Antigravity as follows:

From the main Antigravity interface, click on Settings.
Go to Customizations. Click on Refresh if you still don’t see the MCP Servers. In my case, the 6 MCP Servers were visible as follows:

You can disable any of the MCP Servers if you’d like via the Toggle button. Alternately, you can peak into the tools exposed by any of the specific MCP Servers. As a sample, the Developer Knowledge MCP Server, which provides programmatic access to Google’s public developer documentation, enabling you to integrate this knowledge base into your own applications and workflows.

Here is a sample run when I ask the Agent about a gcloud command for Cloud Armor and it uses the Developer Knowledge MCP server to retrieve the current and accurate information from the Knowledge base.

Prompt : use the developer knowledge mcp server to retrieve the cloud armor gcloud command to do rate limiting.
18:05

Response:

Based on the information retrieved from the developer-knowledge MCP server, Google Cloud Armor supports two types of rate-limiting rules: rate-based throttling and rate-based bans.

Here are the respective gcloud commands and examples:

1. Rate-Based Throttling
Use this to throttle request rates (e.g., return a 429 Too Many Requests or redirect to reCAPTCHA if a threshold is exceeded).

Command Template:
bash

gcloud compute security-policies rules create PRIORITY \
    --security-policy=SECURITY_POLICY \
    {--expression=EXPRESSION | --src-ip-ranges=SRC_IP_RANGE} \
    --action="throttle" \
    --rate-limit-threshold-count=RATE_LIMIT_THRESHOLD_COUNT \
    --rate-limit-threshold-interval-sec=RATE_LIMIT_THRESHOLD_INTERVAL_SEC \
    --conform-action=[allow] \
    --exceed-action=[deny-403|deny-404|deny-429|deny-502|redirect] \
    --exceed-redirect-type=[google-recaptcha|external-302] \
    --exceed-redirect-target=REDIRECT_URL \
    --enforce-on-key=[IP | ALL | HTTP-HEADER | XFF-IP | HTTP-COOKIE | HTTP-PATH | SNI | REGION-CODE] \
    --enforce-on-key-name=[HTTP_HEADER_NAME|HTTP_COOKIE_NAME]
Example (Throttle to 100 requests per 60 seconds per IP address):
bash

gcloud compute security-policies rules create 105 \
    --security-policy=MY_SECURITY_POLICY \
    --src-ip-ranges="1.2.3.0/24" \
    --action=throttle \
    --rate-limit-threshold-count=100 \
    --rate-limit-threshold-interval-sec=60 \
    --conform-action=allow \
    --exceed-action=deny-429 \
    --enforce-on-key=IP
2. Rate-Based Bans
Use this to temporarily ban requests from clients that exceed a configured request rate threshold for a specific period.

Command Template:
bash

gcloud compute security-policies rules create PRIORITY \
    --security-policy=SECURITY_POLICY \
    {--expression=EXPRESSION | --src-ip-ranges=SRC_IP_RANGE} \
    --action="rate-based-ban" \
    --rate-limit-threshold-count=RATE_LIMIT_THRESHOLD_COUNT \
    --rate-limit-threshold-interval-sec=RATE_LIMIT_THRESHOLD_INTERVAL_SEC \
    --ban-duration-sec=BAN_DURATION_SEC \
    --ban-threshold-count=BAN_THRESHOLD_COUNT \
    --ban-threshold-interval-sec=BAN_THRESHOLD_INTERVAL_SEC \
    --conform-action=[allow] \
    --exceed-action=[deny-403|deny-404|deny-429|deny-502|redirect] \
    --exceed-redirect-type=[google-recaptcha|external-302] \
    --exceed-redirect-target=REDIRECT_URL \
    --enforce-on-key=[IP | ALL | HTTP-HEADER | XFF-IP | HTTP-COOKIE | HTTP-PATH | SNI | REGION-CODE] \
    --enforce-on-key-name=[HTTP_HEADER_NAME|HTTP_COOKIE_NAME]
Example (Ban requests for 10 minutes if client IP exceeds 500 requests per 400 seconds):
bash

gcloud compute security-policies rules create 102 \
    --security-policy=MY_SECURITY_POLICY \
    --src-ip-ranges="*" \
    --action=rate-based-ban \
    --rate-limit-threshold-count=20 \
    --rate-limit-threshold-interval-sec=60 \
    --ban-duration-sec=600 \
    --ban-threshold-count=500 \
    --ban-threshold-interval-sec=400 \
    --conform-action=allow \
    --exceed-action=deny-429 \
    --enforce-on-key=ALL

Supported MCP Servers

Antigravity supports a wide range of popular MCP Servers. These are ready integrations that Antigravity ships with. It makes it easier to set the configuration parameters and it updates the mcp_config.json file on its own.

You can do that directly from Settings → Customizations and then Add MCP+ button to add a new server. This brings up a dialog, where you can see the full list of servers:

Click on +Add button to add any MCP Server. I have not validated each of these MCP Server integrations and their workings.

Skills in Antigravity

If you’d like to author and configure Agent Skills in Antigravity, check out the tutorial here.

Tutorial : Getting Started with Antigravity Skills

Codelab

You will learn how to use Google Antigravity to design, build, and deploy a serverless application to Google Cloud. We will build a serverless and event-driven document pipeline that ingests files from Google Cloud Storage (GCS), processes them using Cloud Run and Gemini, and streams their metadata into BigQuery.

Build and Deploy to Google Cloud with Antigravity | Google Codelabs

To be continued

We have a lot more to cover and key among this is Agent Skills and other topics. Stay tuned. Till then, give me feedback.

Key Resources

Let’s get a few resources listed upfront that will help provide you a ready reference to currently available official documentation on Antigravity

Official Site : https://antigravity.google/
Documentation: https://antigravity.google/docs
Download : https://antigravity.google/download
Youtube Channel for Google Antigravity : https://www.youtube.com/@googleantigravity

Antigravity CLI Tutorial Series: Part 2 : Conversations, Conversations and Conversations

Romin Irani — Sun, 24 May 2026 13:15:36 +0000

Welcome to Antigravity CLI Tutorial.

The Series:

Part 1 : Getting Started

Part 2 : Conversations, Conversations, Conversations (this blog)

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

In this part of the series, we are going to understanding the mechanics of Conversations in Antigravity CLI.

You might already have your own definition of what a conversation means? And you would be right in your approximate definition of it. It is definitely a sequence or a thread of messages exchanged between you (user) and the agent.

But you would have multiple questions pop up like:

Are these conversations stored somewhere?
How do we manage multiple threads of conversation? Each thread having its own sequence of unique user and agent interactions.
Can we switch from one conversation to another?

And definitely a lot more questions along similar lines. What follows is my understanding of what Conversations are in Antigravity CLI and an attempt to get the answers to the above questions.

I call these as my experiments since the documentation is sparse at the time of writing and the source code is not open for me to take a peek into. So please correct me if I have hallucinated unintentionally. :-)

What is a Conversation?

First up, let usattempt to define what a conversation means and what better than to ask Antigravity CLI itself. It came up quite well:

In the context of Antigravity CLI, a conversation is an isolated work session or execution thread identified by a unique Conversation ID (e.g., 3b4a1d20–3968–4ed2–90b3–00eea3060b02 ).

Here is what defines a conversation:

State and History: Every conversation preserves a history of interactions (user requests, agent responses, tool calls, and system messages) serialized as JSON Lines (JSONL) transcripts under

/brain//.system_generated/logs/ .
Dedicated Artifacts: Each conversation has its own storage directory

( /brain// ) where structured markdown documents like the implementation_plan.md , task.md , and walkthrough.md are saved and updated.
Scratch Space: Conversations have a dedicated scratchpad directory ( /brain//scratch/ ) for temporary test scripts, helper files, or data files that persist across steps.
Agent Tree: When a main agent invokes a subagent, a new child conversation is spawned with its own ID, allowing agents to work in parallel on specialized sub-tasks while maintaining isolated context.

What is an appDataDir?

Good question. On my mac, it is in my $HOME/.gemini/antigravity-cli folder or ~/.gemini/antigravity-cli folder. So inside of this directory, you will find the following:

Inside this directory, you will find the following folder and sub-folders under it (not all subfolders are described):

brain/ : Contains subdirectories for each conversation (using their Conversation ID) containing:

— .system_generated/logs/ : Chat transcripts ( transcript.jsonl , transcript_full.jsonl ).

— Artifacts: Markdown files like implementation_plan.md , task.md , and walkthrough.md .

Conversation Management commands

There are several in-built commands in Antigravity CLI that we can use for conversation management. They are:

• /clear : Clears the screen and starts a fresh conversation thread.

• /resume (or /switch ): Displays a menu showing your previous conversations, allowing you to choose one to resume.

• /rewind (or /undo ): Rolls back the active conversation history to a previous step (useful if a command failed or you want to try a different direction).

• /fork : Branches the current conversation into a new workspace from a specific step, preserving history up to that point.

/rename : Renames the active conversation with a custom, readable title.

Let’s see it work

Let’s ensure that we are starting a fresh conversation thread. To do that, you can use /clear command. This can be used anytime to create a new conversation. This does not lose any of the previous conversation and we can always switch back to previous conversation threads. We will see all of that in a while.

But for now, just ensure that you have used the /clear command and are ready in Antigravity CLI.

Give the following prompt:

What is Google Cloud Run?

Antigravity CLI gets down to work and produces the following output:

● WebSearch(Google Cloud Run overview features) (ctrl+o to expand)

  Google Cloud Run is a fully managed, serverless platform by Google Cloud that allows you to run containerized applications and services without having to manage the underlying server infrastructure. It combines the flexibility of        
  containers with the simplicity of serverless computing.                                                                                                                                                                                      

  ### Key Features                                                                                                                                                                                                                             

  • Fully Managed & Serverless: Google automatically handles infrastructure management, including server provisioning, operating system maintenance, and scaling.                                                                              
  • Automatic Scaling: Cloud Run scales automatically based on incoming request traffic. It can scale up to thousands of instances to handle high demand, and scale down to zero when there is no traffic, meaning you only pay when your      
  application is actively handling requests.                                                                                                                                                                                                   
  • Any Language or Library: Since it runs Docker/OCI-compliant containers, you can write your application in any programming language (e.g., Python, Node.js, Go, Java, Rust) and use any system library or custom dependency.                
  • Deploy from Source or Container: You can deploy an existing container image from Google Artifact Registry or deploy directly from your source code repository. If deploying from source, Cloud Run uses Google Cloud Buildpacks to         
  automatically package your code into a container.                                                                                                                                                                                            
  • Two Execution Modes:                                                                                                                                                                                                                       
      • Cloud Run Services: For web apps, APIs, microservices, or event-driven applications that respond to incoming web/HTTP requests or gRPC calls.                                                                                          
      • Cloud Run Jobs: For short-lived, run-to-completion tasks (like database migrations, nightly backups, or batch data processing) that do not serve web traffic.                                                                          
  • Hardware and AI Acceleration: It supports deploying workloads on GPUs (such as NVIDIA L4) and using larger machine configurations, making it a viable serverless platform for hosting Large Language Models (LLMs) and running AI inference
  workloads.                                                                                                                                                                                                                                   
  • Integrations: It integrates natively with other Google Cloud services (such as Pub/Sub, Cloud Storage, and Eventarc for event-driven workflows) and supports VPC connectivity to securely access private databases or other internal       
  resources.

But what has it done behind the scenes to persist this conversation thread.

Step 1

The Antigravity CLI instantly performs the following directory setup (I am assuming the following conversation id → 11111111–2222–3333–4444–555555555555):

Creates the Conversation Root Folder:

~/.gemini/antigravity-cli/brain/11111111–2222–3333–4444–555555555555/

Creates the System Logs Folder:

~/.gemini/antigravity-cli/brain/11111111–2222–3333–4444–555555555555/.system_generated/logs/

Creates the Scratchpad Directory:

~/.gemini/antigravity-cli/brain/11111111–2222–3333–4444–555555555555/scratch/ (This folder remains empty until the agent needs to write temporary test scripts or run one-off diagnostics).

Step 2: Logging the Initial Prompt (Internal System Logs)

The CLI creates two JSON Lines files under the .system_generated/logs/ folder:

• transcript.jsonl (assuming that this is a token-efficient log containing truncated text for large outputs)

• transcript_full.jsonl (assuming that this is a full, untruncated log containing exact tool results and text)

If you visit the transcript.jsonl file, you will notice that a JSON record representing your first input step is appended (few fields only since there is a lot of metadata too):

{
 "step_index":0,
 "source":"USER_EXPLICIT",
 "type":"USER_INPUT",
 "status":"DONE",
 "content":"What is Google Cloud Run?"
}

You will also see multiple steps being recorded next in terms of how Antigravity CLI is planning out its execution. I will only reproduce the steps / types, etc and it will be good enough for you to understand. I encourage you to inspect the files on your machine to see all the wonderful details.

{"step_index":1,"source":"SYSTEM","type":"CONVERSATION_HISTORY"...}
{"step_index":2,"source":"MODEL","type":"PLANNER_RESPONSE","status":"DONE","created_at":"2026-05-24T12:14:37Z","tool_calls":[{"name":"search_web","args":{"query":"\"Google Cloud Run overview features\"","toolAction":"\"Searching the web\"","toolSummary":"\"Web search\""}}]}
{"step_index":3,"source":"MODEL","type":"SEARCH_WEB","status":"DONE","created_at":"2026-05-24T12:14:38Z","content":"Created At: 2026-05-24T12:14:38Z\nCompleted At: 2026-05-24T12:14:43Z\nThe search for \"Google Cloud Run overview features\" returned the following summary:\nGoogle Cloud Run is a fully managed, serverless platform that allows you to run containerized applications and services without managing the underlying infrastructure[1][2][3]. It is designed to combine the flexibility of containers with the simplicity of a serverless environment[4].\n\n### Core Features\n\n* **Fully Managed & Serverless:** Google handles all infrastructure management, including provisioning, scaling, and maintenance[1][2]. You simply provide your code or container[3][4].\n* **Automatic Scaling:** Cloud Run s.....}
...
{"step_index":5,"source":"MODEL","type":"PLANNER_RESPONSE","status":"DONE","created_at":"2026-05-24T12:14:46Z","content":" **Google Cloud Run** is a fully managed, serverless platform by Google Cloud ...}

In this way, your current conversation as you go back and forth is persisted.

See what happens if you give a follow up message that says:

What kind of applications can I deploy on Google Cloud Run?

Once you get the response in Antigravity CLI terminal, go back to the conversation id folder and you will see additional steps in the transcript.jsonl file:

{"step_index":6,"source":"USER_EXPLICIT","type":"USER_INPUT","status":"DONE","created_at":"2026-05-24T12:27:18Z","content":"<USER_REQUEST>\nWhat kind of applications can I deploy on Google Cloud Run?\n</USER_REQUEST>\n<ADDITIONAL_METADATA>\nThe current local time is: 2026-05-24T17:57:18+05:30.\n</ADDITIONAL_METADATA>"}
{"step_index":7,"source":"MODEL","type":"PLANNER_RESPONSE","status":"DONE","created_at":"2026-05-24T12:27:18Z","content":"You can deploy a wide variety of applications on...}

Step 3: Agent Analysis and Planning (If coding changes are needed)

Now, let’s say we go a step further and ask it to actually generate/code a sample application for us that can be deployed on Cloud Run:

Create a single page HTML / JavaScript application to deploy on Cloud Run that takes my name and returns me a greeting.
Let's plan it out first.

Here I am specifically asking it to plan it out first. It comes back saying:

 I have created the implementation plan for the Google Cloud Run greeting application.                                                                                                                                                        

  Please review the proposed design and files in the implementation_plan.md artifact. Once you approve, let me know and we will proceed to verify it.

This behind the scenes creates:

~/.gemini/antigravity-cli/brain/11111111–2222–3333–4444–555555555555/implementation_plan.md

Depending on how you proceed, additional markdown files (walkthrough, task list, etc) will be created in the same folder.

As an experiment, go ahead with approving the implementation plan. This will make Antigravity CLI generate the code, test out the server, etc. This will result in additional folders being created but all within the brain/CONVERSATION_ID folder.

If you navigate to your app data folder during/after a coding conversation, here is exactly what you would start seeing something like this:

~/.gemini/antigravity-cli/
└── brain/
└── 11111111–2222–3333–4444–555555555555/ ← Root of the conversation
├── .system_generated/
│ └── logs/
│ ├── transcript.jsonl ← Truncated log
│ └── transcript_full.jsonl ← Untruncated full log
├── implementation_plan.md ← Technical design spec
├── task.md ← Interactive checklist
└── walkthrough.md ← Work summary & verification

A few other things worth mentioning are:

You will find a history.jsonl within the ~/.gemini/antigravity-cli folder that seems to be a index of all conversations.
A conversations folder that holds the conversations in a protocol buffer format. We can leave it as is for now.

Let’s Rewind

What if we want to go back at a point in time in the conversation. Remember we started with asking about Google Cloud Run, then we asked it to generate code for the application and so on. As a result of which, several code files, artifacts etc have been generated.

If I go into shell mode and see the current files in the folder, you can see from the output below, the files that are currently present. So far so good.

● ! ls
  ⎿ Dockerfile
     node_modules
     package-lock.json
     package.json
     public
     README.md
     server.js

Now, give the /rewind command and you should see a list of all interactions that you have had. In my case, you see the current conversation thread with the list of interactions. I can use the keyboard to go up at the specific point in time before the files were generated (8 files changed, etc).

──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Rewind Conversation

  What is Google Cloud Run?

> What kind of applications can I deploy on Google Cloud Run?

  Create a single page HTML / JavaScript application to deploy on Cloud Run tha...
    8 files changed +583 -1

  Could you first plan it out?
    1 artifact generated

  what is the history.jsonl file that you are managing for the conversations

  what is a .pb file and how are you using it for conversations

  (current)

Keyboard: ↑/↓ Navigate enter Select esc Cancel

Once I select to rewind it to a step before all the files were generated and execute that step, it will remove the files generated as is evident from the outputs that I now see.

● ! ls
  ⎿ node_modules
     package-lock.json
     public

The implementation_plan.md and other artifact files also go away from the brain/CONVERSATION_ID folder that we earlier saw. You can try out these scenarios on your machine.

Saving a Conversation with a different name

At any point in time, you can save the conversation with a name that is easier or makes sense to you in terms of the entire thread. Just use the /rename command.

In Antigravity CLI, I simply give the rename Google Cloud Run basics to rename this conversation. It comes back with the following message:

> /rename
  ⎿ Conversation renamed to: Google Cloud Run basics

Switching between Conversations

You can use the /resume or /switch command to switch to another conversation. For example, I see the following:

   CLI Antigravity (tab to cycle)

  Conversations
  Type to search...
> [CURRENT] Google Cloud Run basics 10 steps 8m ago
  Understanding Antigravity CLI Conversations 24 steps 52m ago
  hello 4 steps 1h ago

Keyboard: ↑/↓ Navigate ←/→ Page enter Select f2 Rename ctrl+delete Delete tab Switch Tab esc Go back / Clear search

You can see that our current context is now with our preferred name Google Cloud Run basics and the other ones that you see in the list are the ones that I had here. But you might see another list.

Select any one of these to switch to that conversation and carry on that conversation from there or maybe even rewind, etc.

Switching to an Antigravity conversation

If you have been paying attention to the output shown in the /switch command, you might see an Antigravity and CLI option. This might happen only if you have also installed the non-CLI option i.e. Antigravity on your machine. In my case I have and have interacted a bit with it.

But what is pleasantly surprising is that it is now showing me conversations that have been saved via Antigravity and allowing me to import them. Whew! Let’s try this out:

   CLI Antigravity (tab to cycle)

  Conversations
  Type to search...
> Extracting Invoice Information [Import this conversation? (y/n)] 20 steps 2h ago
  Generate a events website but let's discuss the requirements first. 67 steps 1d ago

Keyboard: ↑/↓ Navigate enter Select tab Switch Tab esc Go back / Clear search

So I select one of the conversations (Extracting Invoice Information) and then press on Enter. It asks me that it needs to import this conversation. This brought up the previous conversation and I was able to carry on with a new message in the thread. Wonderful. Probably this needs a lot more testing.

  <PREVIOUS _ CONVERSATION _ THREAD >

────────────────────────────────────────────────────────────
> What are the files sizes for each of the invoices

● ListDir(/Users/romin/agy-cli-projects/invoice-processing) (ctrl+o to expand)

  Here are the file sizes for each of the invoice image files in your directory:                                                                                                                                                               

  • inv1.png: 273,828 bytes (approx. 273.8 KB)                                                                                                                                                                                           
  • inv2.png: 369,086 bytes (approx. 369.1 KB)                                                                                                                                                                                           
  • inv3.png: 446,932 bytes (approx. 446.9 KB)                                                                                                                                                                                           
  • inv4.png: 343,328 bytes (approx. 343.3 KB)                                                                                                                                                                                           

  (Note: The CHUBB.pdf insurance document size is 42,965 bytes / approx. 43 KB).

One more thing

If you quit your Antigravity CLI at this point, you will notice that there is a message at the end that looks something like this:

Resume: agy --conversation=d1d8a55b-cc27-4dd4-bc62-2f73015960d2 (or -c)

That’s right. Antigravity CLI comes with a command line option to resume a specific conversation via the --conversation or -c parameter. This value has to be the unique conversation id that you see. I think this is useful but might be a bit unwieldy to remember or use.

In any case, the key message is that you now what is going on with this unique conversation id , where the stuff is persisted on your local machine and can discover more. In any case, you can always launch Antigravity CLI and use the /switch command to go to a specific conversation thread. Just remember to use /rename to name them in a way that you understand.

Conclusion

While a conversation in Antigravity CLI is something that is managed behind the scenes for you, it is helpful to understand how the tool is working. Hopefully these examples give you a good idea of what is happening under the hood. I will keep adding more examples to this as I understand this better. See you in latter parts of the series.

Antigravity CLI Tutorial Series

Romin Irani — Fri, 22 May 2026 15:08:49 +0000

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.

Google Antigravity

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.

Google Cloud Platform Technology Nuggets — May 1–15, 2026

Romin Irani — Fri, 15 May 2026 04:50:41 +0000

Welcome to the May 1–15, 2026 edition of Google Cloud Platform Technology Nuggets. The nuggets are also available on YouTube.

Infographic for this post, generated by NotebookLM

AI and Machine Learning

Gemini 3.1 Flash-Lite is now generally available on the Gemini Enterprise Agent Platform. It is a model specifically optimized for ultra-low latency and high-volume production deployments. This addition to the Gemini 3 series focuses on providing precision for agentic tasks such as tool calling, orchestration, and automated pipeline execution while minimizing operational costs. Check out the blog post.

In a mid-cycle update of the Gartner® Magic Quadrant™ for AI Application Development Platforms, Google has been given the #1 ranking across the three use cases assessed in the associated Critical Capabilities report. Download a complimentary copy of the 2026 Gartner Magic Quadrant update here.

Data Analytics

While AI-powered SQL functions are a solid addition to the databases, cost and latency of these functions is a critical factor. An interesting approach called proxy models is now available, which are lightweight classifiers like logistic regression that replace the majority of expensive LLM calls during query execution. These models work by leveraging existing Gemini embeddings of data to identify semantic patterns, allowing the system to perform tasks like binary classification (AI.IF) or multiclass classification (AI.CLASSIFY) on the CPU rather than specialized hardware. The process involves an automated workflow where the engine samples a small portion of data, labels it using an LLM, trains a specialized proxy model on-the-fly, and evaluates its accuracy before deciding whether to use the proxy or the full LLM. This optimization is currently available in BigQuery and AlloyDB. Check out the blog post.

Databases

The Database Center has been infused with several AI-driven updates to assist with the management of large-scale database fleets. The platform now features Gemini-powered intelligence for fleet-wide performance analysis, a natural language chat interface for troubleshooting across services like Cloud SQL and Spanner, and a testing agent to validate the impact of recommendations on latency and throughput before they are applied. Technical enhancements include public APIs integrated with the Model Context Protocol (MCP) for developer tool integration, centralized slow query analysis, and the inclusion of BigQuery inventory and data affiliation to map dependencies between transactional and analytical systems. Check out the blog post.

Bigtable has introduced Bigtable in-memory tier, a new feature within the Enterprise Plus edition designed to provide sub-millisecond read latency by using a hybrid storage architecture. This tier utilizes Remote Direct Memory Access (RDMA) to transfer data directly from memory without involving the system’s CPU or operating system, which helps avoid performance bottlenecks during traffic spikes. It offers approximately 10x higher point read throughput per dollar compared to standard configurations and provides hotspot resistance by supporting up to 120,000 queries per second on a single row. Check out the blog post.

PostgreSQL 18 is now available in in AlloyDB alongside a new Extended Support offering for older versions. This update includes B-tree skip scans for faster data retrieval, parallel GIN index usage for JSON and full-text searches, and native UUIDv7 support for better indexing efficiency in distributed applications. The platform now allows for virtual generated columns to compute data on-the-fly without using additional disk space. For older versions ranging from PostgreSQL 14 to 17, Extended Support provides three additional years of critical security patches and bug fixes beyond the community end-of-life dates. Users can perform in-place major version upgrades to transition to these newer releases. Check out the blog post.

As always, if you are looking to bookmark a single link that covers whats new in Google Data Cloud, check this out.

Developers & Practitioners

The Gemini Enterprise Agent Platform is squarely focused on running, scaling, governing and optimizing agents in production. To do that, requires some key guidance from Google Cloud and that is now available in the form of 5 guides that help transition AI agents from prototypes to production:

Long-Running Agents: Utilize Agent Runtime for maintaining state up to seven days, enabling checkpoint-and-resume and human-in-the-loop approval workflows.
Agent Governance Stack: Implement a five-layer security framework using Agent Identity for isolation, Agent Registry for tool control, and Agent Gateway for policy enforcement.
Multi-Agent Orchestration: Use the Agent Development Kit (ADK) to build graph-based workflows and coordinator-specialist patterns for complex task management.
A2A and MCP Interoperability: Connect agents across organizations and data systems using Agent-to-Agent (A2A) and Model Context Protocol (MCP) standards.
Atomic Agent Blueprints: Access pre-configured architectures in the Agent Garden to accelerate development and avoid manual design errors.

Check out the blog post for more details.

While most of the AI developer tools focus on coding, one of the challenges that remains is that of the outer loop and bridging the gap between local development and production deployment. The Gemini CLI Extension for CI/CD is a tool that is designed to do exactly that. Using the Model Context Protocol (MCP), the extension integrates with Gemini CLI, Claude Code, and Antigravity to automate both “inner loop” tasks, like rapid deployment to Cloud Run via buildpacks, and “outer loop” requirements, such as generating cloudbuild.yaml files and provisioning infrastructure. Key technical features include a pre-deployment security scan to prevent secret leakage, an automated application analysis for containerization, and the ability to provision Artifact Registry repositories and Cloud Build triggers through natural language prompts. For more details, check out the blog post.

Containers and Kubernetes

Google Cloud has introduced an architectural update to Google Kubernetes Engine (GKE) that reduces node startup times by up to 4x to address cold-start latency. This improvement is achieved by reworking node provisioning logic through a combination of intelligent compute buffers, fast-starting virtual machines, and a control plane that allows for instant VM resizing without reboots. These technical changes aim to reduce the need for over-provisioning and improve the scaling of AI inference and batch processing workloads. The feature is currently available for GKE Autopilot and specific NVIDIA GPU hardware, including L4, A100, RTXPRO6000, and H100 nodes, as well as general-purpose compute. For more details, check out the blog post.

Security and Identity

Gartner has named Google a Leader in the 2026 Magic Quadrant for Cyberthreat Intelligence Technologies. You can download the full 2026 Gartner® Magic Quadrant™ for Cyberthreat Intelligence Technologies here.

The second Cloud CISO Perspectives for April 2026 is out. This issue discusses a strategy centered on multicloud and multi-AI environments to address modern security needs. Key technical highlights include the use of Gemini-powered security agents that have reduced alert triage times from 30 minutes to 60 seconds and a new dark web intelligence capability with 98% accuracy. The issue also discusses features in the new Gemini Enterprise Agent Platform, that has an Agent Gateway for identity management, Model Armor for prompt sanitization, and automated Agent Identity verification.

With the Wiz acquisition now complete and highlighted at Google Cloud Next 2026, most practitioners are looking forward to understand how it all comes together under a common platform. In the first Cloud CISO Perspectives for May 2026, the post highlights how the collaboration affects multicloud security and it discusses a strategy centered on developer enablement and automated defense. The collaboration combines Wiz’s cloud telemetry with Google Cloud AI logic to move toward near real-time vulnerability resolution and self-healing infrastructure.

If you are looking to understand the evolving security risks for AI coding agents, this article explains how the attack surface has expanded beyond source code to include the files these agents trust. Threat actors are now targeting repository-level artifacts like tasks.json, settings.json, and Skill.md files to execute code, exfiltrate API keys, or redirect traffic to malicious endpoints by manipulating the agent’s semantic intent. Because these files often use natural language or valid configurations, they bypass traditional signature-based scanners. To counter this, Google Cloud highlights the use of VirusTotal Code Insight to perform semantic analysis, allowing defenders to identify high-risk instructions and hidden supply-chain threats within developer environments.

Infrastructure

Google Cloud has introduced a cluster-level reliability framework for Tensor Processing Units (TPUs) designed to support the training of trillion-parameter AI models.

Storage

If you are looking to address storage bottlenecks in AI and machine learning workflows, you now have Cloud Storage Rapid, a suite of high-performance object storage capabilities designed for data-heavy workloads. This family includes Rapid Bucket, a zonal storage option that provides sub-millisecond latency and up to 15 TB/s throughput to keep accelerators like GPUs and TPUs saturated, and Rapid Cache, which increases read bandwidth for existing buckets without requiring code changes. Check out the blog post.

Write for Google Cloud Medium publication

Stay in Touch

Have questions, comments, or other feedback on this newsletter? Please send Feedback.

If any of your peers are interested in receiving this newsletter, send them theSubscribe link.

[Boost]

Romin Irani — Mon, 30 Mar 2026 11:23:30 +0000

Aryan Irani for Google Developer Experts

Mar 28

Reflections on my Trainings: Gemini for Google Workspace

#gemini #googleworkspace #livetraining #googleappsscript

Comments

6 min read