When Agents Start Running Long: Antigravity's Four Pillars and the Two Commands I Use Most

If generating code is no longer the bottleneck, what does a developer actually spend the day doing?

That question already existed in the era of synchronous autocomplete: Tab completes a line for you, but whether to accept it, and whether the logic meets the requirement, is still your call. In chat-based programming the bottleneck is even clearer. An engineer is assigned a problem, then reads plans, reviews the PRD, and decides on an approach. You are still the one who has to sign off.

Antigravity wants to move one step further. We are going from "generating code and completing a single task" to extending agents inside longer-running autonomous loops, and starting to think seriously about the environments they run in: they do not always have to live on your computer. In one sentence, the team's direction is to let developers become "the agent of agents," or the manager of the system.

That goal rests on four pillars, and it shows up in a few features we use every day.

Four Pillars

The first is the agent engine. It shares configuration, conversations, and credentials across all services. It sounds like infrastructure, but it determines whether you can keep one context across multiple agents and sessions instead of re-explaining everything each time.

The second is artifact verification. This has been a core principle since we founded the company: write generated projects to disk so you can sync and inspect them at any time. It is also my personal favorite feature. I can ask a question, have it generate a report, and read that report online.

The range is still expanding. The latest version supports PDF and Microsoft files, including PPTX, XLSX, and DOCX. We also just announced that the prompt box can accept almost any type of file, video included. Behind that is Gemini's multimodal ability: it can review whatever asset you provide and understand the meaning in images, video, and audio. HTML then presents the same information in a more dynamic form. Since these models launched early this year, it has become a very useful vehicle. One step further, you can now build a complete app, a prototype, or a web app with a backend. The boundary of the word "artifact" has stretched accordingly.

The third is composable custom primitives. We now have a plugin marketplace. If you or your company are building plugins, you can fill out an intent form; we would love to understand how to bring it into the marketplace.

The fourth is defense in depth. This includes OS kernel-level sandboxes, Gemini Enterprise governance, and a set of foundational mechanisms for establishing trust and running operations safely. We are moving these sandboxes to run in the cloud. For enterprise customers, it is also possible to set precise controls and data compliance policies that fit the team and the company.

How Models Divide the Work Matters More Than How Many There Are

Not long ago we released Gemini 4 Argon, and now we have Gemini 4 Carbon. They target complex software engineering: race-condition diagnosis, multi-service refactoring, that kind of hard work. Before the public launch, we tested them with many people inside Alphabet. In just four weeks, some of them built genuinely impressive apps with the system. Argon has become an example of a changed way of working for teams inside and outside Google.

We also have Gemini 3.8 Flash, released six weeks ago, and it is very strong. Then there is NanoBanana2. If you are building an app in Antigravity that needs to generate images, it is useful: without leaving the chat window, the model produces the assets for you. Meaningful placeholder images for a client site, or a specific kind of texture for a game, are exactly the kind of thing it handles.

Model choice is not limited to Google. We offer Anthropic's Claude Sonnet 5.5 and Opus 5.5. Users who need multi-model orchestration can have different models hand work to each other and review each other's output in a single interface.

One hard number Gemini 4 brings to production systems is a one-million-token input context and a one-million-token output context, unprecedented until now. In Antigravity, though, we limit context based on extensive research into the best balance of speed, performance, and cost. You can also choose the effort level you need. The default is medium, but if you are using features like Teamwork Preview or Boost, setting Argon-class large models to low can significantly extend your usable time.

Subagents can also be assigned different models. A common pattern is a Pro-grade model for orchestration and Flash for execution; some people do the reverse. Flash has strong development ability, and its quota lasts longer. Using it for execution, subagent review, or running bash commands directly is a use case I have found to be excellent. Argon supports custom subagents with team-collaboration capabilities. Handing architecture and audit to 3.8 Flash while Argon orchestrates and reviews is one of the most cost-effective combinations available right now.

Some Numbers from Production

These are not benchmark scores. They are production cases shared at the launch.

YouTube used Argon to analyze front-end code and cut CPU usage by 50%; emoji rendering alone accounted for about 45% of the overhead. Wing used it to find 18 defects in physics and aerodynamics simulators. One team cleared 72.4% of its bug queue in three hours. Another migrated from Fortran to Rust, achieved a 1.8x speedup, and found and fixed four runtime authorization defects along the way.

I have been testing Argon thoroughly myself. The most direct feeling is this: an app that took me three years to build can now be built in an afternoon. That is exciting, but it also forces me to recalibrate my expectations. Full-stack engineering is broadening, from the app itself to building platforms, running services, and bringing apps onto local hardware devices.

In Long Loops, Manage Context Deliberately

Every operation in Antigravity's agent loop sends the current conversation history, the outputs, and the loaded conversations to the model. As a conversation grows, this becomes real cost.

With Gemini 4 Argon's context window, we can automatically summarize old conversations and checkpoints before they reach the model backend. You can also use the in-tool /compact to control the degree of compression precisely, and run /context at any time to see exactly what is using tokens.

Two habits are worth keeping. First, periodically check your installed skills and enabled MCP servers, and remove skills you no longer need. The stronger the models get, the less you need to pile on skills. Second, maintain your rules files. On Argon in particular, the trend is toward leaner, more efficient rules rather than cramming in every preference.

Plans and Quotas

Every Antigravity plan includes Gemini 3.8 Flash, and in the extension, Tab autocomplete is unlimited. But Pro and Ultra are what make Gemini genuinely interesting: Argon, plus models such as Claude Sonnet 5.5 and Opus 5.5. We offer a mix of five-hour reset windows and weekly limits, and credits can be used at any time. Organizations can use Gemini Enterprise to get a system tailored completely to the company.

grill-me: Let the AI Interrogate You First

People sometimes ask which commands and development patterns I use. My favorite is grill-me.

Using it is simple. Open a chat window, give it a task about the codebase, and ask it to "interrogate me." You can also ask it to go harder. For example: make a plan for modernizing this codebase, consider a cross-platform framework, list all the options, and show the trade-offs.

grill-me puts you, the human, in the role of one of the reviewers in the process. It asks a series of questions to help you clarify what you actually want to build. It also usually does some research before building. The questions are generated by Gemini or Argon; when it comes to asking questions, Argon can ask things that 3.8 Flash simply cannot.

You can pick one of the options it offers or write your own answer, then follow the suggested steps. During the demo you can click back at any time to what you were viewing, then close it. Voice input is wired to a dedicated Gemini audio model, and its understanding of the goal is remarkably good. Remote control supports it now too, so I often talk about this product while holding my phone.

/btw: Side Questions Without Breaking the Main Thread

Another feature I really like is /btw. It runs outside your current environment, which makes it good for asking a side question while the main task keeps running: explain this codebase, or give me an overview of the codebase.

The demo is a project with iOS, Android, and web targets, and I deliberately left a lot of older APIs in it. The main task is running, and /btw answers another question at the same time. You can close it whenever you want; the question is saved, so you do not lose it.

The combination flows well: the main loop makes progress, and the side question fills in understanding. When your input is needed, your phone or even your watch notifies you, which is another reason I like the remote control. The entry point is antigravity.google.com. Beyond the local environment, we recently launched a remotely hosted version as well.

Get the Decisions Right Before Letting It Run

The real value of grill-me is not how much it asks, but that it moves the key decisions earlier. Token runs take time, and they can be expensive. If the goal, the options, and the trade-offs are settled before implementation, the long loop that follows is running in the right direction.

That is the core of Antigravity at this stage: not getting the model to write a few more lines of code, but putting the human in the right position to manage agents that run for a long time.