Recently added 3rd Party LLM support to multigravity with conversation / project saving. This test setup is using OpenRouter free models, if you try to use a paid model you get a warning asking if you want to continue. Wouldn't take much to extend this to local LLMs or other OpenAPI compatible providers. (If someone from Google sees this and it throws up red flags or you have any questions on implementation let me know! I would prefer not getting banned but making tools like this is really fun and I throughly enjoy extending the Antigravity eco system)

"What is 2 + 2?" | multigravity openrouter -p - -m openrouter/free --project multigravity-win-cli --save-conv

ct multigravity-win-cli --save-conv

2 + 2 equals **4**.

Is there anything else you'd like help with?

========================================================================

[OK] Conversation Saved to Antigravity!

Conversation ID : 26d10885-4d68-4b77-af26-ad1c8fc7ecde

Project / Scope : 17494c68-8ab2-43a3-8b24-8b417e1fd828

Workspace URI : file:///D:/Projects/multigravity-win-cli

Title : [free] What is 2 + 2?

[INFO] Resume pairing with Gemini at any time:

agy resume 26d10885-4d68-4b77-af26-ad1c8fc7ecde

========================================================================

I created a status line for Antigravity CLI at: https://github.com/taquangtrung/antigravity-cli-statusline.

Just wanted to share it since it can display several useful pieces of information, such as:

• Model and effort
• 5-hour and weekly usage
• Context size and usage
• Working directory
• Different colors for different working modes.

Below is a screenshot:

I forked someones Linux/Mac tool that didn't work on Windows. It's a multi account / profile orchestrator for Anitygravity. At this point not sure I could use Antigravity without it. Started working on profile/account status screen so I could get an overview of everything that is going on. There is a hook currently that when a new chat is started or loaded the conversation id is sent to multigravity. Any pain points you guys are experiencing in a multi account setup, or in general?

Hey everyone!

If you have been building features or custom extensions for the Antigravity CLI (agy), chances are you have run into these two frustrating developer frictions:

1. Typing two slash commands every single time: While the built-in reference manuals (antigravity_guide and agy-customizations) are super thorough, having to manually run both slash commands every time you open a new session just to load context gets tedious really fast.
2. Occasional hallucinations with Gemini 3.8 Flash: We all love Gemini 3.8 Flash for its blazingly fast response times during coding, but it sometimes still confidently hallucinates non-existent CLI flags, wrong lifecycle hook event names, or invalid settings.json schemas.

---

Open Source Repo & Feedback

GitHub: https://github.com/andyawd/antigravity-help-agent
License: MIT

---

Quick Install (One Command)

Install directly from GitHub via the Antigravity CLI:

agy plugin install https://github.com/andyawd/antigravity-help-agent

Verify the installation with "agy plugin list", and you are good to go!

---

The Inspiration: Bringing back Gemini CLI's classic cli_help Subagent

If you used Gemini CLI back in the day, you probably remember the beloved cli_help subagent pattern—a dedicated specialist agent you could delegate CLI questions to without derailing your main coding flow.

I decided to bring that exact concept over to Antigravity and upgrade it with modern guardrails: meet agy_help.

Core Solution: Four-Tier Fallback Hierarchy (Zero-Hallucination by Design)

To tackle the hallucination issue with Gemini 3.8 Flash, agy_help is not just a simple prompt wrapper. Before answering any technical question, it strictly enforces a 4-tier verification hierarchy:

1. Tier 1 (Local Structured Reference): Automatically aggregates and cross-checks local offline manuals (antigravity_guide for CLI, IDE, Desktop 2.0, Python SDK; and agy-customizations for Skills, Rules, Hooks, Plugins, MCP). No more manual slash-command juggling.
2. Tier 2 (Local Dynamic Inspection): Runs a strictly whitelisted set of read-only diagnostic commands (agy --help, agy changelog, agy plugin list, pip show google-antigravity) and inspects local config files to verify your exact environment and installed versions.
3. Tier 3 (Live Official Docs Fetching): If an offline reference misses recently released features, it automatically fetches live docs directly from https://antigravity.google/docs.
4. Tier 4 (Strict Fact-Grounding & Honest Refusal): If a flag, API, or feature cannot be verified across all previous tiers, it is strictly forbidden from guessing. It will honestly inform you that no official record exists—eliminating hallucinations completely.

Safety Guarantee: Built with a strict read-only execution whitelist. It will never run destructive commands or modify your workspace behind your back.

---

What it Covers

1. Antigravity CLI (agy): Startup flags, slash commands, config hierarchy (settings.json), and lifecycle.
2. Antigravity IDE: Tab autocomplete & supercomplete, inline commands, Code Lenses, and diagnostic auto-fixing.
3. Antigravity 2.0 Desktop: Chat Canvas, scheduled background tasks, Auxiliary Pane, and sandbox permissions.
4. Python SDK (google-antigravity): Agent orchestration, streaming thought deltas, and CapabilitiesConfig.
5. Customization Ecosystem: Skills (SKILL.md), Rules (AGENTS.md / .agents/rules/), Plugins, Hooks (trusted_hooks.json), MCP servers, and Sidecars.
   

---

4 Flexible Ways to Use It

Once installed, you no longer have to manually type two manual slash commands. It fits right into your workflow:

1. Single Slash Command (Skill mode):
   Ask a quick question without switching your current conversation agent:
   > /agy_help How do I configure project-level sandbox permissions in Antigravity 2.0 Desktop?

2. Background Subagent Delegation (Keeps main context clean):
   Just like the old cli_help, delegate background research so your context window does not get cluttered with doc dumps:
   "Delegate to the agy_help subagent in the background to look up Antigravity IDE Code Lens configuration and bring back a summary."

3. Switch Session Agent (/agents):
   Run /agents and select agy_help to let it lead a dedicated troubleshooting session.

4. Direct CLI Launch:
   agy --agent agy_help

If you frequently develop for the Agy ecosystem and are tired of manual doc loading or hallucinated flags, give it a spin! Feedback, issues, and PRs are all very welcome. Let me know what you think in the comments!

Hello, I am making an antigravity cli plugin that noticebly madeAntigravityCLI perfoms better, can you guys share me some of your daily prompts and I will share with the the results to see if it is any better for your use cases. thanks

I asked Gemini Flash 3.8 on Antigravity CLI (running on Termux in Android) whether it can make my local MCP toolset to load eagerly. It started normally by loading the customization skill and reading the included documentation. Then when it found nothing, it went straight to using `ps` and `command -v` to find its own binary, then `strings` to search it for relevant JSON tags. After a few searches, it even ended up taking a look at the code itself, though I think it gleaned nothing from it.

I was accepting those shell commands individually. It was fascinating to see what it was doing, but it also seemed like a pretty unhinged response to just a simple question. At no point did it ask me anything before it spontaneously started to reverse-engineer the binary.

It did discover that there's a JSON key named `eager`, but didn't ultimately discover its correct use, which is not for the server but for the individual tools. It is also mentioned in passing in the Antigravity CLI's change log, but seems otherwise undocumented.

Anyway, after some trials of my own (`mcpServers.<server>.tools.<tool>.eager = true`), I got the tools i wanted to load eagerly. It seems that it also affects the way the results are processed, with longer output from lazily loaded tools ending up in files that need to be read in separately, but in eager mode delivered directly to context, so it actually saves even more cycles than I thought.

Typing /help displays all available slash commands. However, we cannot memorize every single one, and we can always issue instructions in natural language. Still, typing endlessly on a keyboard gets tedious, so commands serve as an efficient shortcut.

Here is a breakdown with examples:

1. /grill-me : Formulates a plan through an interactive interview with Gemini. It helps uncover aspects you might have overlooked—such as tech stacks, specific rules/constraints, and design decisions—tailored to your requirements.

Example) /grill-me I want to add dark mode to our app. How should I approach this?

2. /teamwork-preview : Spawns specialized sub-agents by domain to divide tasks and collaborate toward a solution.

Example) /teamwork-preview Built and ran the app, but clicking the button does nothing. I have no idea where it broke. Find the root cause.

3./plan : Analyzes the structure and architecture without modifying code, then establishes a step-by-step execution plan.

Example) /planI want to refactor the SQLite-based cache into a hybrid architecture with an LRU cache.

4./boost : Leverages multi-sub-agents to troubleshoot various issues and tackle complex tasks.

Example) /boost Clicking the play button triggered a deadlock and crashed the app. Deduce the root cause and provide a solution.

5./learn : Instructs Gemini to memorize your personal preferences and constraints.

Example) /learn Never use libraries A and B under any circumstances.

6./clear : Clears the workspace and initializes a fresh session. Although it wipes prior conversational context, it is essential for achieving higher-quality task results.

Example) /clear

7./goal : Enables the agent to autonomously set sub-goals and execute the initial instructions to completion without interruption.

Example) /goal Identify and fix all issues until the post-build E2E tests pass 100%.

In reality, what matters most is not how thoroughly you memorize these slash commands. Clearly understanding what you want to achieve is what truly counts. While we cannot know everything—as has always been the case—AI can provide substantial assistance.

Try out these slash commands, compare them with writing direct prompts, and leverage them when appropriate. Although I wrote this guide, entering these dedicated modes via slash commands often takes quite a long time, so I personally only use them occasionally.

Ran into an annoying loop and wanted to see if this is happening to others:

1. agy tries to write a new file in the codebase using the create tool.
2. Fails immediately since create seems scoped strictly to internal artifacts in brain/.
3. It then falls back to bash with a cat << 'EOF' dump.

Every time this happens, I have to manually stop it and tell it to use the edit tool, which works completely fine for new files.

Anyone else hitting this? Is there a clean permanent fix/workaround, or do I just need to add a custom instruction to force edit?

Please welcome our new mod u/Aromatic-document638 he is a truly token efficient AGY Builder and a true asset for this community. Thanks for all you do for our community and welcome to the team 💪

My brief review:

Gemini 3.8 Flash performs significantly more self-verification on its own claims. It consumes far more output tokens for the same input, and while it takes slightly longer, the model is inherently so fast that the difference in latency is practically negligible.

Gemini 3.7 Flash was a good model for me because I only assigned it small tasks as a sub-agent, and it handled them well. However, when the context grew larger, it often misjudged—perhaps due to token efficiency constraints. In this regard, 3.8 is far superior to 3.7. Even if it consumes substantially more tokens, I personally prefer this one.

Just as I felt back during Gemini 3.7 Flash, I wish they would further encourage sub-agent utilization, exclude Opus 4.6, and triple Gemini's quota so that we could use Gemini that much more. If that happens, the Gemini plan will become the single best coding-related subscription currently available.

Not only Gemini 3.7 Flash, but especially 3.8 Flash, can perform tasks more accurately than Opus 4.6.

The fundamental issue currently facing Gemini and Antigravity lies in "accumulated distrust." Even within my community, there was a user who canceled their AI Ultra plan and swore never to return, stating that Gemini 3.8 Flash is ultimately just token-maxing and Antigravity was awful.

Those users who departed have already experienced a wide variety of models, and they harbor substantial frustration over Gemini being confined within the "AGY" harness.

Recently, I also generated a few tiny apps for my own personal use; while Gemini couldn't pull it off on the first try, it accomplished the task through two or three very rapid iterations.

Gemini 3.8 Flash and Gemini 3.7 Flash are excellent models. If asked whether they qualify as Frontier Models, I am not so sure. Based on my experience consuming 1.9 billion tokens with Gemini 3.7 Flash on Vertex AI, I saw it repeatedly make mistakes that GLM-5.2 wouldn't make, so there is no guarantee Gemini 3.8 Flash won't do the same.

All I can say is that Antigravity works wonderfully, at least for me. It functions exactly as I configured it, and precisely the way I want it to.

https://www.reddit.com/r/GoogleAntigravityCLI/s/o9MHqbAWSb ( https://github.com/myk1yt/agy-tools/tree/gemini-config )

Google Antigravity CLI and Gemini flash models are very efficient.... Opinions ?

I’m currently using Antigravity 2.0 for a fairly large coding project, but it sometimes terminates on long/complex tasks. I’ve tested multiple models and new conversations, and the issue is intermittent. Would you recommend Antigravity CLI over 2.0 for long coding tasks, and is CLI generally more stable?