https://preview.redd.it/jl4lkbd3jqsh1.png?width=1439&format=png&auto=webp&s=ea74d10fe1f78561f02f60debf99cc6d1b283c8d

https://preview.redd.it/ovfjx8d3jqsh1.jpg?width=1600&format=pjpg&auto=webp&s=7ef1f948b3dcbb2dcb70fc539e206ea45595c800

https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-argon/

I think virtually all models are doing well in other capabilities, and one of the skills I value most recently is cybersecurity, which Gemini4 excels in this area.

Recently, the MiMo v2.6 Pro, GLM-5.3, and DS v4.1Flash were models with significant strengths in this field, and gemini has joined us here. I hope Gemini 4 doesn't refuse the developers' requests to strengthen security.

First, this Gemini4 will be primarily available to AI ultra users. AI Pro or Plus users will likely have to spend quite a bit of time on them.

* It is not yet available.. Soon!!

https://preview.redd.it/lftab57kaqsh1.png?width=594&format=png&auto=webp&s=960cd00538a0fabd5e5e0587893188eda6ef3a17

AI Pro users cannot yet choose Gemini 4.

Still, there is an update for Agy-cli. It has been updated to 1.2.14.

## 1.2.14

. Added the Queued Messages option to /config: keep the default Queue to hold follow-up messages until the current turn ends, or choose Send Immediately to interrupt the agent with them; it can also be set with "queuedMessages": "send-immediately" in settings. json, which was previously ignored

. Improved remote-control start on Linux machines without a systemd user service manager, such as most containers: instead of failing, it now starts the daemon as a background process and warns that it will not restart after a crash or start at boot; remote-control status shows its PID and remote-control stop shuts it down

. Improved loading long conversations: resuming a conversation with thousands of steps is noticeably faster because the CLI no longer scans every step up front

. Improved automatically generated conversation titles to take images and files attached to your first message into account, so screenshot- or file-driven requests get specific titles and messages with only attachments get a title too

. Improved the sign-in error shown to accounts blocked for a Terms of Service violation, which now includes a link to submit an appeal

. Changed -- json-schema to reject plain text, bare type names such as string, and missing schema files instead of silently treating them as a string schema; these inputs, and any schema whose root is not "type": "object", now fail at startup with an error and exit code 1

. Fixed the prompt cursor drifting away from the end of the text after emoji such as Aor @, or scripts with combining marks such as Devanagari and Thai, especially inside tmux, and fixed prompt wrapping splitting such characters across two lines

. Fixed the agent hanging when it tried to view a pipe, socket, or device file, and a conversation getting stuck with INVALID_ARGUMENT errors after the agent viewed a truncated MP4, MOV, or M4A recording; both are now rejected up front with a clear message

. Fixed resuming a conversation whose history had a missing step, for example after a crash or an interrupted write, hiding the most recent steps and letting new messages overwrite them

*Even this video was created using Antigravity and Google Flow. My colleagues recommended other tools, but since it was a project that had to be started with certain limitations due to its nature as a tutorial, I decided to use Google Flow, which is supported by Google AI’s services.

Two weeks ago, when Gemini3.8Flash and Agy-Cli were upgraded, I started working on creating a simple software application within three days, along with /grill-me. I plan to post an article about this after that.

But it took two weeks to get it done. 70% of the content was created using Agy-Cli + Gemini. The rest was generated using various LLMs like Qwen3.8Flash, GLM5.3Flash, KIMI3, and GLM5.3, along with Zoo Code.

It’s an app that I wanted to create for myself at some point. I started working on it under the pretext of the release of Gemini3.8Flash. Now, it’s finally available. Basically, this app has two main functions.

https://preview.redd.it/y08o0le0a4ph1.png?width=896&format=png&auto=webp&s=176376e4443e5965dfe4c987809bc622a6c5d2ad

- When you type in your native language, it will be translated into the desired language.
- When you drag the text on the screen, it will be translated into your native language.

https://emebala.org/emebalachat

On September 4th, the first Prompt I entered was as follows:
(Originally written in Korean.)

/grill-me When I open this folder on D:\OneDrive\Projects\Translatingchat, I see that the system for translating using llama cpp is very well-developed.

I want to use this same concept to create a translation function within my online chat interface. For example, if I type in Korean in Discord’s chat window, it should be translated into the language I’ve set as the default language. Do you understand what I mean? 

For instance, if I open the app and type “I am a person” into the chat window, it should be automatically translated into “i am a people”. In other words, the language I’ve entered will be automatically translated and replaced with the translated text. 

This is all that’s needed to make this work. But I hope it can work on any platform—whether it’s Discord, Reddit, or any other social media platform, or even emails.

Agy-Cli + Gemini3.8Flash operates at an incredible speed. As a result, the extremely advanced models can be created in a very short time. The software that enables these functions is also developed quickly.

However, in actual use, there are many bugs and errors that occur. It’s necessary to turn on terminal logs and continue using the system while identifying these problems. We also need to research ways to prevent security issues and other problems from occurring.

I can’t move the entire prompt here, but I’ll share a few examples.

/boost Please inspect the entire application to see if there are any security vulnerabilities, verify whether the UX is at its optimal state, and ensure the local AI mode powered by llama.cpp works properly. If not, fix it."  

/boost Review
"C:\Users\******\AppData\Local\Emebalachat\logs\emebalachat_260908212610.log\" and inspect the entire codebase to catch any bugs or errors that might degrade user experience...

/boost Check every piece of code in Emebalachat one by one, and verify if it violates any of the following rules or harms user experience... (Detailed multi-paragraph description of mouse drag translation tooltip behavior, source/target language persistence, and reboot survival rules)

Once done, use /teamwork-preview to improve UX while keeping maximum simplicity, check for bugs,  verify functionality with unprimed subagents, and report back to me.

With Agy-Cli and Gemini3.8Flash, I was able to fix bugs at an extremely fast pace in the beginning. However, with my Google AI Pro, it became impossible to continue due to the usage limit. I had to use another coding tool I use, Zoo Code, to continue fixing the bugs.

To be honest, before Agy-cli got updated enough to become useful, and even before I used the old gemini tool, which could do everything without any actual work being needed, it was extremely difficult to create even simple applications. But I can say that it’s not the case right now.

Of course, if gemini3.8flash is still used alone, without using subagents, then it’s possible to experience a decrease in concentration. However, when 2 to 6 subagents are utilized to manage the context and divide up the tasks, it’s possible to complete tasks with incredible speed and accuracy.

* By the way, there’s also a shared post on my GitHub account for those who find it troublesome to call for subagents every time. In addition, I’ve also created other agents. I’ll share them with you later.

https://www.reddit.com/r/GoogleAntigravityCLI/comments/1vqwac8/sharing_my_agycli_harness_setup/

https://github.com/myk1yt/agy-tools/tree/gemini-config

• Windows (PowerShell / CMD):

git clone -b gemini-config --single-branch https://github.com/myk1yt/agy-tools.git agy-gov; cd agy-gov; .\scripts\install.bat; cd ..

• macOS / Linux (Bash):

git clone -b gemini-config --single-branch https://github.com/myk1yt/agy-tools.git agy-gov && cd agy-gov && chmod +x scripts/install.sh && ./scripts/install.sh && cd ..

And one more thing I’d like to suggest is that when agy-cli gets updated, there might be some changes that could cause the existing settings to no longer work properly. And since everyone has their own personality and work style, it’s important to consider this when using agy-cli. Just think about it: if you give 10 people a lawn mower and ask them to mow the grass, each person will work in their own unique way. The same goes for using agy-cli: you need to create your own “Harness” based on the default settings provided by agy-cli. After all, it’s better to create your own custom Harness based on those defaults. While it’s great to share many of the knowledge and resources available in the community, it’s also important to take those ideas and adapt them to your own needs. You’ll learn a lot from this process.

Some people will need this tool for 3D purposes, while others will use it for websites. Everyone has different needs, so the most important thing is to figure out what’s best for you before choosing or making the tool.

We live in an era when we can create our own software. At least you, who are reading this text, are one of those people who use such tools.

https://preview.redd.it/6lwteqz996nh1.png?width=1072&format=png&auto=webp&s=b9a4be0ba8725faa7801f0c560d869a77285af88

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.

https://preview.redd.it/q1rb9h24f6nh1.png?width=1195&format=png&auto=webp&s=207ff112148ec87aa37ea9f991bee199408b0b05

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 )

I originally intended to post this two days ago, but Windows 11 suddenly encountered a reset bug, forcing me to perform a clean install and restore my PC... That is why I am posting this behind schedule.

*There may be bugs or errors. Feel free to let me know, though I cannot guarantee when they will be fixed. Since the source code is publicly available at the GitHub URL, you are also welcome to modify and use it directly.

As you all know, Antigravity-Cli is not open source. So I built it in a slightly different way. I found it tedious to type /usage every single time, and I was curious about my token consumption, which led me to create this tool.

The token usage is not exact. It is calculated locally via a tokenizer, and because it is a conservative estimate, it can be 20% to 40% lower than the actual token usage. Even though the token usage is an estimate, it is useful because it allows for long-term tracking and helps identify which models and reasoning efforts consume more tokens.

Built it to support as many languages as possible. The language is determined based on your system language. The video is in Korean to demonstrate the installation process, and the screenshots were taken after switching to English for instructional purposes.

The source code is available at

https://github.com/myk1yt/agy-tools

and anyone who needs it is free to modify and use it.

https://reddit.com/link/1w20wn3/video/sx01s90z5emh1/player

Although the video appears that way because I use Agy-cli in the bottom terminal pane of VS Code, you can also access the dashboard window via a web browser in standard PowerShell.

https://preview.redd.it/yuxhtji86emh1.png?width=1857&format=png&auto=webp&s=ea21605bafc419247c675d2f6d4662ac1c20fef2

https://preview.redd.it/29i3icei6emh1.png?width=795&format=png&auto=webp&s=de1b9650316d2c847887d6d9d1fbe415e36a0908

Although I have also provided the one-shot installation method below, if by any chance it doesn't work,

instruct Gemini:
"https://github.com/myk1yt/agy-tools is to have statusline and dashboard features for agy-cli, please install this for me."

Install

Requirements: Node.js 16+(nodejs.org) · Antigravity CLI installed

Windows (Command Prompt / PowerShell)

git clone https://github.com/myk1yt/agy-tools.git
cd agy-tools
scripts\install.bat

macOS / Linux

git clone https://github.com/myk1yt/agy-tools.git
cd agy-tools
chmod +x scripts/install.sh && ./scripts/install.sh

Done. That's it — the installer:

1. Registers global commands: agy-tokens, agy-tools, agy-dashboard
2. Auto-configures the statusline: merges statusLine into ~/.gemini/antigravity-cli/settings.json (existing settings preserved, auto-backup, idempotent)

After install

1. Restart Antigravity CLI (agy) — the live token badge appears on the terminal statusline:⚡ [Antigravity] Turn: 1.2k ($0.0002) | Today: 45.8k ($0.0068) | Cache: 82% | 5h: ▰▰▰▰▱ 79% | 7d: ▰▱▱▱▱ 21%
2. Open the web dashboard:agy-tokens --html --open (or click the 📊 Dashboard link on the statusline)

Uninstall

npm unlink -g agy-tools    # removes global commands
# optionally remove "statusLine" from ~/.gemini/antigravity-cli/settings.json

Although commands such as agy-tools dashboard can be used without launching agy, they will rarely be used, so please refer to the GitHub page only if you need them.

https://preview.redd.it/4wplv5h9cemh1.png?width=937&format=png&auto=webp&s=9e56864c97ac1529fea9e07680c16aa68431968f

Users complaining about the KIMI usage limits here are not bots or black consumers. Even originally, the Usage allowance was smaller compared to OAI, but they were users who accepted that and continued using the service.

To begin with, the 7-day quota only became usable 4 days after this month's reset. And I still have 20 days left until my next reset.

https://preview.redd.it/4bg544jmywlh1.png?width=301&format=png&auto=webp&s=69c292d66f5d1eec33e8e094299d94b416e32560

https://preview.redd.it/wrkimgnbywlh1.png?width=815&format=png&auto=webp&s=01c65c3328ad75c3a98f8c8d817886af793a9dd6

My usage over 10 days sits at 20.61%, which amounted to around 200M tokens used. Even if I max out the remaining period, my cumulative monthly token usage will not even reach 800M tokens.

If you check the post I wrote a month ago, I had calculated that 3.5B tokens were usable per month. This directly aligns with other users' suspicions that the usage allowance has been cut down to 1/4.

https://www.reddit.com/r/kimi/comments/1v0yhng/calculating_the_estimated_actual_price_and_total/

*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.

https://preview.redd.it/xaxkj8klonjh1.png?width=801&format=png&auto=webp&s=f2cce81b67e5b182bbe1ca274d22ff695bce0074

https://preview.redd.it/14xzt4sponjh1.png?width=793&format=png&auto=webp&s=4a43dbca80290aab126779310c00b63fe3014c29

https://preview.redd.it/8b6u1v5uonjh1.png?width=757&format=png&auto=webp&s=ea984f65dba227af187b123ec3787157a2e457cd

During a refactoring process using Kimi Code, with only two verification phases remaining, I decided to purchase $20 worth of extra usage to complete the rest of the phases.

However, from this experience, if anyone claims they buy extra usage to get actual work done with KIMI CODE—rather than Web KIMI—I will take that as a complete lie. This is just as expensive as using Opus via API. Unless your company is willing to foot the bill or you have zero concept of money, it is prohibitively expensive for individual or small-scale developers to use.

Had I known it would be like this, I would have much rather spent $20 on ChatGPT Plus and utilized GPT-5.6 Sol High's weekly allowance over several hours.

Although I knew that extra usage pricing is determined by API rates, I had no idea it would be this outrageously expensive.

My Allegro usage had decreased considerably compared to before, and I topped up to substitute part of it with extra usage, only to realize that doing so is completely pointless due to the exorbitant cost.

If anyone is considering buying KIMI's extra usage, take that money and either subscribe to ChatGPT Plus for $20 or purchase something like OpenCodeGo to find alternative solutions.

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.

3.7Flash New here

50% Discount

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.

https://preview.redd.it/q7wyx2yos9jh1.png?width=1201&format=png&auto=webp&s=319c8cd9ef4a540015f6d8fd3e45a64a92410f97

https://preview.redd.it/3s412rh6t9jh1.png?width=999&format=png&auto=webp&s=94e0724d66e1e2508c7d76f862c5b10b32612450

https://preview.redd.it/80w7thj8t9jh1.png?width=999&format=png&auto=webp&s=b8c5609e5903956637c9192c3a522bebbd92e4f8

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.

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!

https://preview.redd.it/uq48rmexcwhh1.png?width=496&format=png&auto=webp&s=bad4f7c4404b7f3eebf34c07347b370fc0f56092

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.

https://preview.redd.it/w7fa8c2idfhh1.png?width=850&format=png&auto=webp&s=0bb0a1ce8e684fca5e58f52ef8348830c7470a55

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.

https://preview.redd.it/2cesrniupfhh1.png?width=485&format=png&auto=webp&s=a4b0cfa02317e92a3034577450b492d25d028f26

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.

https://preview.redd.it/z1fhash6ifhh1.png?width=711&format=png&auto=webp&s=5e5680312fa9f1bd8cdfdb7c1722f78e0793d3cf

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.

https://preview.redd.it/85zvrc49k6hh1.png?width=507&format=png&auto=webp&s=f469639038595965616cf8a8698763d736a7a73c

And since I don't have any remaining quota, I can't test it myself. Please try it out and share your review.

Of course, it clearly varies depending on the type of work. However, the Plus plan provides a lot more tokens than expected.

Using only terra xHigh for a 1-week turn on ChatGPT Plus, I used 185 million tokens. That calculates to about 740 million tokens for 4 weeks. And that's for a mere $20 plan. Considering that Tibo occasionally resets it, the Codex plan is truly amazing.

https://preview.redd.it/h14l8kdip5gh1.png?width=1052&format=png&auto=webp&s=e24ed90a181719ef7b7ba28562f6f682a6fc334d

"Let me know if you understand what I want. Let's start once I approve."

Yes... Gemini thought I approved it on its own and started the task.

He is a mischievous boy

https://preview.redd.it/lalmjwrxj2gh1.png?width=1445&format=png&auto=webp&s=65ffc0a76eed6fbc1adc1211360e041ef3997c63

While conducting the LLM test for the redacted section above, I also tested the remaining models.

First of all, these test results do not fully reflect the absolute performance of each model. I use Zoo Code, and I have assigned different roles to more than 10 modes, such as Orchestrator, Architect, Ask, Code, Debug, and Research modes. The Code mode used in this test is responsible for instant coding, testing, and simple refactor and debugging, and I utilized its default mode settings as they were.

What I wanted to find out in the test was the stability of , but since I was already doing it, I decided to test Kimi K3 as well. To prevent cheating, the testing arena and grading arena were isolated, and grading was handled by ChatGPT 5.6 Sol High.

Originally, even for a single project, it is my principle to plan and proceed in multi-stage phases, but due to budget issues, I had to plan and execute using only a single Code mode, which is somewhat disappointing; however, it has reaffirmed my belief that at this point, any AI model is extremely useful.

Note 1: -
Note 2: ChatGPT 5.6 Luna Max paused once due to consecutive C++ verification failures.
Note 3: Kimi-k2.7-code finished the C++ stage and left the next stages as tasks for next time.
Note 4: Kimi-k2.7-code performed context compression once due to its 252k context limit.
Note 5: AIs that are poor at frontend design seem to be poor at Flutter as well?
Note 6: I wanted to use Kimi K3 in Code mode because it was better than GLM 5.2 High, but gave up due to cost issues... Seeing the test results, it makes sense.
Note 7: Gemini 3.6 Flash was granted the privilege of /goal since it was a default agent without separate optimization.
Note 8: ChatGPT 5.6 Luna Max, along with DeepSeek, is the king of this era from a practical standpoint.

Regret 1: If given enough budget and time, I would like to add Go and TypeScript and formally go through the Plan -> Code -> Debug and fix loop stages.
Regret 2: Naturally, even if you assign the same task to the same model, the outcomes will vary. Therefore, I should have run the same test three times, but there are time and budget constraints. *To be honest, it's just to satisfy my personal curiosity.

Thought 1: Models with smaller parameters perform well at first, but lose steam toward the end.
Thought 2: In practice, thorough research, search, and planning are handled by the Architect mode, and even after coding is finished, audits by Debug and Ask take place, so this test is somewhat detached from reality.
Thought 3: DeepSeek is simply fast, Kimi K3 is fast without any redundancies, and Gemini has insane speed.
Thought 4: -

Those who subscribe after hearing about KIMI K3's reputation seem to feel that KIMI's pricing is expensive even though it provides a token volume worth the price.

The two posts below are about measured practical/felt token volumes based on actual usage:

https://www.reddit.com/r/kimi/comments/1v0yhng/calculating_the_estimated_actual_price_and_total/

https://www.reddit.com/r/kimi/comments/1v2vo92/comment/ozj524p/

For reference, I am utilizing a combination of multiple models. In my current Zoo Code setup, MiMo v2.5 Pro acts as the orchestrator,
GPT5.6 Sol High handles planning,
GLM5.2 High does the heavy-lifting coding,
Simple coding is handled by MiMo v2.5,
And Kimi K3 Max is in charge of Debug and Ask modes.
Research and organization of the codebase are handled by the affordable MiMo v2.5.

I am currently using the Allegro plan, but its quota is not enought for K3 + k2.7-code. It might be sufficient for some users, but at least not for me.

For the best Frontend design, using kimi code + k3 might be optimal. However, if that's not the case, it's better to use other coding tools, leaving heavy-thinking tasks to K3 and inexpensive tasks to cheaper models.

DeepSeek V4 Flash is one of the best combinations.

MiMo v2.5 is also a great option.

According to my working environment and experience, the pricing is as follows. There is no significant difference in the outputs. Making a good plan is the most important thing; if advanced models like K3 set a good plan, fast and inexpensive models handle the rest well.

https://preview.redd.it/2g0prrb45mfh1.png?width=642&format=png&auto=webp&s=18febe50cd0dca04fbf0a688e1a244124a005d68

https://preview.redd.it/rqe38zua5mfh1.png?width=979&format=png&auto=webp&s=2ab306e75bece9b1c5e35f8edd977f01121e2a84

Token Price/M : DeepSeek V4 Flash Max > MiMo v2.5 > DeepSeek V4 Flash High

Looking it up now,
DeepSeek V4 Flash High used $0.25 for 32 million tokens,
MiMo v2.5 used $0.51 for 40 million tokens,
and DeepSeek V4 Flash Max used $0.39 for 30 million tokens.

Assuming the price of MiMo v2.5 is 1,
DeepSeek V4 Flash High can be seen as 0.6127 and Max as 1.0196.

Cheaper models do not mess up their jobs. Therefore, I recommend using a combination with cheaper models. Smaller models like Qwen3.6 35B also generate sufficiently good results as long as they have a good plan. Compared to that, MiMo v2.5 and DeepSeek V4 are models akin to geniuses.