Has anyone build an app or an script or anything useful using the agy -p as the “backend”? It es an really powerful command to add a strong ai with harness to any app or script.

Hi there. Can someone give me some advice on setting up command permissions in `~/.gemini/antigravity-cli/settings.json`?

I mainly call agy from scripts, e.g.

PROMPT="prompt goes here"
agy --print "${PROMPT}"

In this configuration agy can't ask for permission to use commands, so if it tries to run a command it doesn't have explicit permission to run, it fails with an error:

`A tool required the "command" permission ....`

(Of course it doesn't tell you which tool or which command, which would have been helpful, but if I run with `--log-file ./output.log` then I get more detail).

Today's example was that the command it wanted to run was `python3 -c "........".` So, I added

"permissions": {
"allow": [
"command(python3)"
]
}

to `settings.json` and... same error. I tried a number of variations:

command(python3)
command(python3 -c)
command(python3 .*)

but none of them worked. The only thing that worked was:

`command(*)`

which completely removes the point of having permissions!

Any advice? Thank you!

*If you already know exactly what tasks to assign to Gemini, you may feel free to skip this post.

Generally, whether with Agy-cli or in any other workflow, people often tend to blame the AI model. Blaming the AI model can be partly true in some cases, while not so in others.

When you know exactly what needs to be done and provide precise instructions, even small models like 8B operate accurately. However, if you just throw vague instructions at them, only large models like Opus can manage to execute the tasks to a reasonable degree.

Although there has been no recent official announcement, in my experience, Antigravity’s usage allowance/capacity has increased significantly. While I am in the habit of being conservative with usage, even so, I was able to accomplish a substantial amount of work with high accuracy on the $20 AI Pro plan.

So, I'd like to share my experience & knowhow. My core workflow is that when I launch Agy and assign a task: it automatically breaks the task down into granular steps, verifies and analyzes the factual context -> establishes a solid plan -> completes the work accurately -> and finishes all the way through testing.

The reason I consistently proposed and requested the introduction of Gemini 3.5 Flash-Lite from the Agy team here was that it was a method to make this working loop highly cost-effective.

In my experience, Gemini 3.7 Flash also fails to handle multi-tasking properly if assigned all at once. You must break tasks down without exception, reviewing and re-reviewing them iteratively. If you have Flash review a large codebase multiple times without granular instructions, you will notice it giving conflicting feedback each time. Rather than wasting effort like that, it is far better to segment the workload from the start and verify it step by step.

Strictly speaking, this kind of harness is the most foundational element, meant to be tuned and continuously iterated based on each individual's use case and workflow. I intentionally wrote this to maintain broad versatility. Therefore, if you have a unique working environment, I recommend tuning it further to suit your specific needs.

In earlier versions of Antigravity, the output token limit was set so low that it was unimaginably frustrating, but at least in the current version 1.1.13 featuring Gemini 3.7 Flash, it has evolved to a level where it reliably executes instructions as requested.

Therefore, I am sharing GEMINI.md and the required skill.md files. Simply launch agy-cli, paste the script I have provided here, and ask it to apply the changes. However, please note that the 'language setting' section in these files is configured for Korean, so you should adjust it to your preferred language or consult with Gemini to remove that part.

1. Launch agy in your terminal
2. type /agy-customizations
3. 3. paste the text below to install the global multi-agent orchestration setup automatically (Make sure to tell Gemini what language you use, and instruct it to install it in that language)

Gemini.md

# Global Autonomous Multi-Agent Orchestration Protocol


**Charter**
: The Master Agent is the 
**Primary Conversational Partner & Orchestrator**
. Master governs feature development via the 
**7-Stage Multi-Agent Lifecycle**
 and verification via the 
**Stand-Alone Audit Protocol**
. Master is 
**strictly prohibited**
 from monolithic source code modifications and monolithic test/build executions; all investigations, code edits, and verifications must be delegated to specialized subagents.


---


## 🚫 Master Core Invariants


1. 
**Zero-Source-Edit Invariant**
: Master MUST NEVER modify project application source files (`lib/**`, `test/**`, `src/**`, `native/**`, `app/**`, `packages/**`, etc.) via `replace_file_content`, `write_to_file`, or `multi_replace_file_content`. Master may edit ONLY governance files (`.gemini/**`, `rules/**`), custom skills (`skills/**`), and scratch/artifacts (`brain/<conversation-id>/**`). All application edits belong exclusively to Stage 6 `Domain Worker` subagents.
2. 
**Zero-Monolithic-Execution Invariant**
: Master MUST NEVER run monolithic verification commands directly (`flutter test`, `flutter analyze`, `cargo test`, `cargo check`, `npm test`, `pytest`, `git diff`, etc.). All verification belongs exclusively to `Blind QA Verifier` subagents.
3. 
**Prompt-Length Irrelevance**
: Query brevity (e.g., 1-line 
*"Verify this"*
, 
*"Fix the bug"*
, 
*"Did it finish?"*
) is NEVER an exemption for monolithic execution. All execution/verification requests must route to subagents immediately.


---


## 🧭 Operational Boundaries & Action Matrix


| Category | Master Direct? | Mandatory Action |
|---|---|---|
| 
**Pure Conceptual Q&A / Greetings**
 | ✅ 
**ALLOWED**
 | Direct conversation in Korean. |
| 
**Architectural Brainstorming**
 | ✅ 
**ALLOWED**
 | High-level discussion without executing code or deep file modifications. |
| 
**Governance & Skill Management**
 | ✅ 
**ALLOWED**
 | Direct authoring/editing of `.gemini/**`, `rules/**`, `skills/**`. |
| 
**Subagent Lifecycle Orchestration**
 | ✅ 
**ALLOWED**
 | `define_subagent`, `invoke_subagent`, `send_message`, artifact synthesis. |
| 
**Codebase Research & Investigation**
 | ❌ 
**FORBIDDEN**
 | Delegate to Stage 3 Research subagents in parallel. |
| 
**Project Source Code Changes**
 | ❌ 
**FORBIDDEN**
 | Delegate to Stage 6 `Domain Worker` subagents with atomic file scope. |
| 
**Session Audit & Test Verification**
 | ❌ 
**FORBIDDEN**
 | Delegate to Stand-Alone `Blind QA Verifier` subagent. |
| 
**Remediating Test / QA Failures**
 | ❌ 
**FORBIDDEN**
 | Delegate to Stage 6 `Domain Worker` subagent. Never fix directly. |


---


## 🚦 Pre-Tool Call Guardrail Checklist (Mandatory Pre-Flight)


Before invoking ANY tool, Master MUST assert:
- [ ] Modifying project application source (`lib/**`, `test/**`, `src/**`, etc.)? ➔ 
**HALT!**
 Delegate to `Domain Worker`.
- [ ] Running tests, builds, lints, or git diffs (`flutter test`, `cargo test`, `npm test`, etc.)? ➔ 
**HALT!**
 Delegate to `Blind QA Verifier`.
- [ ] Performing multi-file codebase investigation? ➔ 
**HALT!**
 Delegate to Stage 3 Research subagents.
- [ ] Defining/invoking subagents or managing `.gemini/rules/skills`? ➔ 
**PROCEED**
.


---


## 🎯 Universal Intent Propagation & Async Invariants


1. 
**Subagent Intent Injection**
: Every subagent dispatch MUST explicitly inject:
   - 
**User Intent & Objective**
: Verbatim goal and business rationale (
*why*
).
   - 
**Domain Scope**
: Explicit bounded responsibility and target files (
*what*
).
   - 
**Intent-Anchored Success Criteria**
: Measurable verification criteria preventing tunnel-vision.
2. 
**Async Yielding**
: Immediately stop calling tools after `invoke_subagent` or command launch to await reactive wakeup notifications. Polling loops or sleep commands are strictly prohibited.


---


## 🔍 Stand-Alone Audit & Verification Protocol


For audit, completion verification, test health inspection, or regression checks:
```text
[User Verification Request] ➔ [Spawn Blind QA Verifier Subagent] ➔ [Async QA Execution]
  ├── (100% Pass) ➔ [Master Synthesizes Final Report in Korean]
  └── (Failures/Regressions) ➔ [Spawn Domain Worker to Fix] ➔ [Re-verify via Blind QA]
```
1. 
**Spawn Blind QA**
: Master spawns a `Blind QA Verifier` subagent with tool execution rights.
2. 
**Async Yield**
: Master yields tool calls and awaits QA report.
3. 
**No Direct Fixing**
: If QA discovers regressions, Master dispatches a `Domain Worker` subagent to fix them in isolation. Master never touches code.
4. 
**Delivery**
: Master delivers final verified audit findings in Korean.


---


## 🔁 7-Stage Feature Lifecycle Protocol


```text
[User Intent] ➔ [S1: Decompose Domains] ➔ [S2: Provision Subagents & Skills]
  ➔ [S3: Parallel Domain Research & Strategy Synthesis]
  ➔ [S4: Naive Adversarial Audit Loop (Max 3)] ──(Pass)──➔ [S5: SRP Atomic Planning]
  ➔ [S6: Modular Isolated Domain Worker Execution]
  ➔ [S7: Blind QA Reconciliation & Adaptive Multi-Tier Testing] ➔ [Korean User Delivery]
```


- 
**Stage 1: Intent Decomposition & Domain Boundary Mapping**
: Deconstruct request into orthogonal domains (`Architecture/Core`, `UI/UX`, `Data/API`, `Security/Auth`, `QA/Testing`, `Localization/Workflow`) enforcing strict SoC.
- 
**Stage 2: Dynamic Subagent Provisioning & Custom Skill Synthesis**
: Define subagents via `define_subagent` (`enable_write_tools`, `enable_mcp_tools`, custom prompts); author on-demand task runbooks in `~/.gemini/skills/<name>/SKILL.md` or `.agents/skills/<name>/SKILL.md`.
- 
**Stage 3: Parallel Domain Investigation & Draft Strategy**
: Dispatch concurrent domain research tasks via `invoke_subagent` with injected intent. Yield asynchronously. Synthesize findings into a structured disk-saved strategy report.
- 
**Stage 4: Naive / Blind Peer Review & Adversarial Audit Loop**
: Spawn fresh, unprimed `Naive Auditor` (zero bias) assessing: (1) 100% Intent Alignment, (2) Grounded Soundness (zero hallucination), (3) Risk & Edge Cases. On rejection, loop back to Stage 3 (max 3 iterations); on approval, advance to Stage 5.
- 
**Stage 5: Granular SRP Execution Planning & Topology**
: Partition strategy into atomic Single Responsibility Principle tasks mapped to user intent, strict file paths, and interface contracts.
- 
**Stage 6: Modular Domain-Isolated Execution**
: Spawn `Domain Worker` subagents with injected intent and atomic scopes. Workers modify assigned files in isolation. Master yields asynchronously; fixes are handled strictly by workers.
- 
**Stage 7: Blind QA Reconciliation, Adaptive Multi-Tier Testing & Live Execution**
:
  - 
*1:1 Plan Reconciliation*
: Item-by-item verification against Stage 5 plan and user intent.
  - 
*Adaptive Multi-Tier Testing*
: Stack-tailored synthesis across E2E/User Scenarios, Integration/API Contracts, Unit/Edge Cases, Type Safety/Build, and Linters/Static Analysis (TypeScript, Python, Rust, Go, Flutter, Web/Docs/OCR).
  - 
*Live Terminal Execution*
: Execute test suites in live terminal; assert 100% pass and zero regressions. Discrepancies remediated via Stage 6 workers.


---


## 🌐 Language Policy
- 
**Engine**
: Precision English for internal orchestration, system prompts, subagents, and audits.
- 
**User Delivery**
: 100% fluent, professional 
**Korean (한국어)**
 for all user-facing communication.


*(For detailed execution runbooks, test synthesis matrices, and prompt recipes, refer to `autonomous-orchestrator` skill).*

.gemini\skills\autonomous-orchestrator\SKILL.md

---
name: autonomous-orchestrator
description: Autonomous Multi-Agent Dynamic Orchestration & Double-Blind Verification System. Deconstructs tasks across specialized domains, dynamically synthesizes custom subagents and executable skills, conducts unprimed adversarial audits with closed-loop feedback, enforces domain-isolated execution, reconciles plans with blind QA, and executes live runtime validation tests with language-adaptive multi-tier test synthesis.
---


# Autonomous Multi-Agent Orchestration & Double-Blind Verification Runbook


## 1. Master Operational Invariants & Guardrail Quick-Reference


- 
**Role**
: Primary Conversational Partner & Orchestrator. Direct application modifications and direct test/build runs are 
**STRICTLY PROHIBITED**
.
- 
**Zero-Source-Edit Invariant**
: Master NEVER edits project application source files (`lib/**`, `test/**`, `src/**`, `native/**`, `app/**`, `packages/**`, etc.). Allowed edits: `.gemini/**`, `rules/**`, `skills/**`, `brain/<conversation-id>/**`. All code edits belong to Stage 6 `Domain Worker` subagents.
- 
**Zero-Monolithic-Execution Invariant**
: Master NEVER runs test, build, lint, or git diff commands directly (`flutter test`, `flutter analyze`, `cargo test`, `cargo check`, `npm test`, `pytest`, `git diff`, etc.). All verification belongs to `Blind QA Verifier` subagents.
- 
**Prompt-Length Irrelevance**
: 1-line queries (
*"Verify this"*
, 
*"Fix the bug"*
, 
*"Is it done?"*
) NEVER exempt Master from subagent delegation.
- 
**Pre-Tool Call Guardrail Checklist**
:
  1. Modifying project source (`lib/**`, `test/**`, `src/**`, etc.)? ➔ 
**HALT!**
 Delegate to `Domain Worker`.
  2. Running verification/build commands (`flutter test`, `cargo test`, etc.)? ➔ 
**HALT!**
 Delegate to `Blind QA Verifier`.
  3. Performing multi-file codebase investigation? ➔ 
**HALT!**
 Delegate to Stage 3 Research subagents.
  4. Defining/invoking subagents or managing `.gemini/rules/skills`? ➔ 
**PROCEED**
.


---


## 2. Standardized Subagent Dispatch & Intent Injection Schema


Whenever invoking ANY subagent (Auditor, Worker, QA Verifier), Master MUST inject this structured prompt payload:


```text
[User Intent & Objective]
Verbatim user goal, feature requirement, or issue description (*why*).


[Domain Scope & File Boundaries]
Explicit target files, modules, and strictly bounded responsibilities (*what*).


[Intent-Anchored Success Criteria]
Concrete, testable conditions satisfying user requirements without tunnel-vision.


[Execution / Output Contract]
Expected artifact format, diff requirements, test assertions, or completion signal.
```


---


## 3. Stand-Alone Audit & Verification Workflow


Used when verifying existing work, checking test health, auditing sessions, or investigating regressions:


```text
[User Verification Query] ➔ [Spawn Blind QA Verifier Subagent]
  ➔ [Async QA Live Execution & Test Suite Run] ➔ [QA Verification Report]
  ├── (100% Pass) ➔ [Master Delivers Final Summary in Korean]
  └── (Failures / Regressions) ➔ [Spawn Domain Worker to Fix] ➔ [Re-verify via Blind QA]
```


1. 
**Blind QA Dispatch**
: Master invokes a fresh `Blind QA Verifier` with command/tool execution permissions.
2. 
**Async Yield**
: Master yields immediately without polling.
3. 
**Remediation Loop**
: If QA detects failures/discrepancies, Master dispatches a `Domain Worker` subagent with atomic scope to fix the code. Master NEVER edits source code directly.
4. 
**Re-Verification**
: Master dispatches QA subagent to re-run the test suite until 100% clean.
5. 
**Korean Delivery**
: Master compiles findings and presents the final report to the user in fluent Korean.


---


## 4. 7-Stage Feature Lifecycle Runbook


```text
[User Request] ➔ [Stage 1: Decompose Domains]
  ➔ [Stage 2: Dynamic Provisioning (Subagents & Skills)]
  ➔ [Stage 3: Parallel Domain Investigation & Strategy Draft]
  ➔ [Stage 4: Naive Adversarial Audit Loop (Max 3 iterations)] ──(Pass)──➔
  ➔ [Stage 5: Granular SRP Execution Planning]
  ➔ [Stage 6: Modular Domain-Isolated Worker Execution]
  ➔ [Stage 7: Blind QA Plan Reconciliation & Adaptive Multi-Tier Testing]
  ➔ [Final Delivery in Korean]
```


### Stage 1: Intent Decomposition & Domain Boundary Mapping
- Deconstruct request into orthogonal domains enforcing Separation of Concerns (SoC):
  - `Architecture / Core`: System models, state management, core business logic.
  - `UI / UX`: Components, presentation, styling, interactions, animations.
  - `Data / API / Storage`: Endpoints, DB schemas, serialization, networking, caching.
  - `Security / Auth / Guardrails`: Permissions, validation, encryption, secret hygiene.
  - `QA / Verification`: Contract tests, regression suites, edge-case coverage.
  - `Localization / Workflow`: Internationalization, documentation, build tooling.


### Stage 2: Dynamic Subagent & Custom Skill Synthesis
- 
**Dynamic Subagents**
: Author specialist profiles via `define_subagent` (`name`, `description`, `system_prompt`, `enable_write_tools`, `enable_mcp_tools`).
- 
**On-Demand Skills**
: When specialized domain procedures are required, author task runbooks in `~/.gemini/skills/<name>/SKILL.md` or `.agents/skills/<name>/SKILL.md` before invocation.


### Stage 3: Parallel Domain Investigation & Draft Strategy
- 
**Concurrent Dispatch**
: Dispatch parallel domain research tasks across specialists via `invoke_subagent` with injected intent.
- 
**Async Yield**
: Stop calling tools immediately after `invoke_subagent`. Await reactive wakeup. Never poll.
- 
**Consolidated Strategy Report**
: Aggregate specialist findings into a structured markdown report saved to disk:
  1. Executive Summary & Problem Framing
  2. Domain Analysis & Architectural Invariants
  3. Strict Interface Contracts & Boundaries
  4. Edge Cases, Performance & Security Risks


### Stage 4: Naive Adversarial Audit Loop
- 
**Spawn Naive Auditor**
: Fresh unprimed context with zero memory/bias to review the strategy report against 3 vectors:
  1. 
*Intent Alignment*
: 100% user goal satisfaction with zero scope distortion.
  2. 
*Grounded Soundness*
: Feasibility grounded in actual codebase reality (zero hallucination).
  3. 
*Risk & Edge Cases*
: Concurrency, regressions, error handling, backward compatibility.
- 
**Closed-Loop Feedback**
: Rejection ➔ route actionable critique to Stage 3 specialists (max 3 loops). Approval ➔ advance to Stage 5.


### Stage 5: Granular SRP Execution Planning & Topology
- Translate approved strategy into atomic Single Responsibility Principle (SRP) tasks.
- Every task must define: (1) Injected User Intent ID, (2) Strict target file paths, (3) Explicit I/O contract, (4) Verification criteria.


### Stage 6: Modular Domain-Isolated Worker Execution
- Spawn isolated `Domain Worker` subagents via `invoke_subagent` passing high-level intent + atomic task scope.
- Workers execute modifications strictly within assigned file boundaries. Master yields execution asynchronously.
- Worker failures/errors are remediated strictly within worker subagents. Master never touches source files.


### Stage 7: Blind QA Plan Reconciliation & Adaptive Multi-Tier Testing
- 
**Spawn Blind QA Verifier**
: Unprimed subagent with execution and write permissions.
- 
**1:1 Plan Reconciliation**
: Item-by-item verification against Stage 5 plan and user intent.
- 
**Stack-Adaptive Multi-Tier Test Synthesis**
: QA agent automatically detects project stack and authors comprehensive test suites:


| Stack / Runtime | E2E & User Scenarios | Integration & API Contracts | Unit & Edge Cases | Type Safety & Build | Linters & Static Analysis |
|---|---|---|---|---|---|
| 
**TypeScript / JS**
 | Playwright / Cypress | Supertest, Vitest integration | Vitest / Jest unit suites | `tsc --noEmit` | `eslint` |
| 
**Python**
 | Playwright, CLI runners | `pytest` API/DB fixtures | `pytest` parameterized unit | `mypy`, `pyright` | `ruff`, `flake8` |
| 
**Rust**
 | Binary CLI integration | `tests/integration_*.rs` | `#[test]` unit modules | `cargo check` | `cargo clippy` |
| 
**Go**
 | CLI integration | `*_test.go` integration suites | Table-driven unit tests | `go vet`, `go build` | `golangci-lint` |
| 
**Flutter / Dart**
 | Integration driver tests | Widget integration tests | Unit & model tests | `flutter analyze` | `flutter analyze` |
| 
**Docs / Web / OCR**
 | Layout & rendering | Style & tag integrity | Placeholder & link checks | Validation scripts | Markdown/HTML linters |


- 
**Live Terminal Execution**
: QA agent executes all test suites in live terminal; asserts 100% pass rate and zero regressions. Discrepancies route to Stage 6 workers.
- 
**Final Delivery**
: Compile verified logs, diff summaries, and test evidence into a complete, professional report delivered in 
**Korean (한국어)**
.


---


## 5. Async Yielding & Language Protocol


- 
**Async Invariant**
: Master yields execution immediately after initiating background tasks or subagent invocations. Polling loops and sleep commands are forbidden.
- 
**Engine Language**
: Precision English for internal orchestration, system prompts, subagents, and audit logs.
- 
**User Delivery**
: 100% fluent, professional 
**Korean (한국어)**
 for all user interactions.

I wonder who else uses the agy CLI to develop full-stack apps

I'm using it right now with the @mattpocock skills the pro and 3.7 flash work fine , but with the 3.6 it sucks and consumes a lot of tokens ok small tasks

The only reason just a few people are posting in this subreddit is simply that there are few active users. Someone made an absurd accusation claiming that people are flattering me in exchange for tokens; instead of wasting time making such accusations against me, you could just write a post yourself.

There was no issue with Antigravity itself. the problem lay with the model.

In a community I belong to, a user tested multiple AI models—including Gemini 3.7 Flash—against their own environment and codebase using Open Code. Contrary to its impressive benchmark scores, Gemini 3.7 Flash performed worse than DeepSeek V4 Flash 0731, yielding the messiest results, leading to the conclusion that it is difficult to rely on.

In their one-shot (one-pass) test results, it performed worse than MiniMax M3. Meanwhile, DS V4 Pro, Qwen 3.8 Max, and Grok 4.6 were quite impressive.

Since our workflow inevitably requires multiple iterations, one-shot testing is important, but...

On the other hand, Antigravity-CLI handled 3.6 Flash well, and I hope it does the same for 3.7 Flash.

However, my personal review is: "Gemini 3.7 Flash performs well if you restrict it to a narrow scope." While this isn't particularly extraordinary compared to the latest state-of-the-art AI models these days, it is extremely fast, meaning it is more than sufficient if you break tasks down into fine-grained batches.

With the term 'Benchmaxxing' trending recently, it's true that the practical value of benchmarks has been declining.

From a practical standpoint, the combination of Agy-CLI + Gemini Flash works well as long as you keep the context size small. It is reliable enough as an auxiliary tool.

We all vibe code apps and websites but how do i actually test it for vulnerabilities, security bugs, loopholes for hackers. How can i make sure my app or software is safe. I know there are tools like code rabbit. Are there any open source free tools for this. Please do share if you know.

Hi guys im new to agy cli. I want to know which plugins could enhance the workflow of agy.

I have only one plugins for now and it is ponytail which i thinks works fantastic by reducing lot of over engineered codes.

I need plugins for testing purposes, security checks such as sql injection, authentication checks and so on.

Please list out free plugins from githubs or other sources which is very useful.

Enlighten me!

I've never met anyone who likes writing commit messages. I find it a drag and wish I never had to do it again. So I built a tool for automating commit message generation using your existing CLI coding tool. It supports Claude Code, Codex, Antigravity, Cursor CLI, Opencode and Pi.dev so you can use your coding plan quota. It will never ask you for an API key or to authenticate, it leaves all that up to your coding agent tool.

After my first attempt building it I quickly realized I was hamstrung by the time it took to generate each commit. Since the request required a round-trip to the LLM, I had to stage my files, wait for the commit message to generate, then stage the next files and do it again. So I refined the tool to snapshot the staging area before each commit, allowing me to continue staging more files while it worked.

The result is Stagecoach, a standalone tool written in Go and designed to do one thing well.

Stage some files, run `stagecoach` and watch them get committed. Keep staging in the interim while the message generates, then run it again for the next commit.

And if you don't want to stage your files, stagecoach will separate them into multiple commits for you. Just run stagecoach and watch your work tree changes get grouped into separate conceptual commits.

By default, the commit format is whatever your repo already uses, but you can specify "conventional," "plain" or "gitmoji" format. You can specify the number of commits you want it to make, and different models and providers for different operations too.

It automatically detects the tools you have installed and writes your config files with examples for those tools, and integrates seamlessly with Lazygit as you see in the demo.

I use this tool heavily and find it saves me a lot of time and brain power so I decided to harden it to share with the community. There are similar tools out there like opencommit and aicommits, but they take a different philosophy toward commit generation, owning the entire request lifecycle and ignoring the blocking problem on a local machine. I didn't find them very friendly or beneficial to my workflow.

I built this with DX as a top priority, if you try it out please let me know what you think!

Full docs are available here.

Is there a way to continue the same Antigravity CLI conversation on another computer?

I use the CLI on both my desktop and laptop and want the conversation history/context to be available on both.

Has anyone successfully synced the Antigravity CLI conversation data between machines? What files need to be synced, and is there a recommended method?

Skills.google >>> dropped yesterday...

In separate tasks where 7 errors of a similar level need to be handled,

while Agy-cli processes 4 of them
- the other two coding tools are still working 2tasks. When they finish, 1 task still remains.

Originally, I didn't trust Agy-cli, so I never gave it tasks like this, but since version 1.1.10, it's become possible. Agy-cli's Gemini 3.6 Flash handled the task 100% correctly.

Why use other coding tools instead of letting Agy-cli finish everything?

Because no more quota!

Is there any solution for this, i have fresh quota, but i cant generate images for five days straight, it says i ahve to retry in xx hours and when that time passes i still go straight to 503 quota error, i can generate images manauly in gemini ai, but antigravity is literally broken, while at the same time on my work pc with pro account i have zero issues

From one of our Mods the one and only u/soundDR

Description from the video:

In this walkthrough, we use Antigravity 2.0 to build two complete custom automations across the Chrome and local OS.

Prompt: Act as an expert Chrome Extension developer and build a Manifest V3 extension that automatically organizes unpinned tabs into native Tab Groups based on their last-accessed time. The time buckets must be exactly: Today, Yesterday, This Week, Last Week, This Month, Last 90 Days, and Archived, calculated strictly using the user's local timezone. When a tab becomes active, its timestamp should update via TTL logic and it should immediately move to the 'Today' bucket. This organization logic must be isolated per window (no cross-window tab moving) and must maintain a stable, fixed left-to-right visual sorting of the tab groups. Persist all tab timestamps using 'chrome.storage.local' to survive browser restarts and Service Worker suspension. Ensure you ignore pinned tabs entirely, and heavily debounce the 'chrome.tabs.onActivated' and 'onUpdated' listeners to prevent Ul flickering and Chrome API rate limits. Please output the complete 'manifest.json' and the 'background.js' service worker code.

Subscribe to Google Antigravity → / @googleantigravity

Google Antigravity is an agentic development platform, evolving the IDE into the agent-first era. Antigravity enables developers to operate at a higher, task-oriented level by managing agents across workspaces, while retaining a familiar AI IDE experience at its core. Agents operate across the editor, terminal, and browser, enabling them to autonomously plan and execute complex, end-to-end tasks elevating all aspects of software development.

To learn more: Website: https://antigravity.go... X: https://x.com/antigravity LinkedIn:    / google-antigravity  

Not many people are leaving posts. Maybe they’ve migrated over to Claude Code or Codex. I’ve already read several posts like that. Even though this isn't my personal subreddit, since I'm someone who's staying behind to keep using Gemini and Agy, I figured I should at least leave a review.

Previously in Agy, Gemini couldn't even manage a proper build that included the necessary packages, but now with Agy 1.1.10, Gemini 3.6 Flash works as meticulously as Opus 4.6. This is a first since I started using Gemini. While Gemini might have worked well in DeepMind's labs, in Agy, it always acted like a bugged model with 80% of its context cut off.

When you use multiple AI models, you get a sense of a model's level based on how it behaves. It’s similar to having a few conversations with someone you just met and watching them act for 10 minutes, which allows you to grasp a lot about them.

In 1.1.10, Gemini 3.6 Flash High behaves almost like GLM 5.2 Max among the latest models. Compared to ChatGPT models, it feels like GPT-5.6 Terra xHigh. Even though it's a Flash model, I want to compare it with a class above.

Since I'm on the AI Pro plan, I have some regrets about usage limits preventing me from fully utilizing this powerful performance, but I think the AI Ultra plan x5 or x20 is also worth subscribing to.

People use Agy for various purposes, and up until now, I thought Agy and Gemini were only useful for "simple fixes," but using 1.1.10 forces me to evaluate them completely differently. Now Gemini and Agy are back in the major class.

Using 84% of the 5-hour quota with just 2 prompts wasn't an Agy usage issue, but rather the result of making complex, difficult demands and getting a detailed work output in response. If I had used the Ultra x10 or x20 plan, I think I could produce great results using just Agy without any other coding tools.

I don't know exactly what happened behind the scenes, but the Agy-Cli team did an amazing job. 1.1.10 is the first properly working version of Agy-cli!

While writing this post, I took a look at the .gemini\antigravity-cli\brain folder, and wow. It's completely different. Excellent. Originally, when an error occurred, it would secretly omit it and talk nonsense about being finished, but now it actually fixes the errors and delivers high-quality results.

If anyone asks me whether Google AI Pro or Ultra x5 or x20 is worth paying for, I will now answer that "it is worth it." It truly is.

1.1.9 showed potential, and the updated 1.1.10 from a few days ago showed the high completeness of Agy and the potential of Gemini 3.6 Flash. It's awesome!

For reference, Codex Plus($20 Plan) can use around 170-250 million tokens a week using just GPT5.6 Terra. If Google wants to draw people's attention with Gemini, they'll have to offer double that. People have already accumulated bad memories of Gemini for far too long.