Opinions on Google Open Knowledge Format in markdown? Is someone using it?

AGY Builders: Here is another great example of how amazing it is to build projects with Antigravity CLI.

🚀 Google Sunsets Gemini CLI – Enter "Antigravity CLI"

Google has officially discontinued the Gemini CLI, replacing it with a new command-line interface tool called Antigravity CLI (or agy). The creator behind the Creator Magic channel provides a firsthand look at this transition, exploring its features, pitfalls, and integration into modern development workflows.

Key Takeaways:

• The Switch: Gemini CLI is no longer supported. Google is pushing developers toward the new agy tool, which is installed via a simple terminal command.
• Closed Source Concerns: Unlike the previous Gemini CLI, which was open-source, Antigravity CLI appears to be closed-source, which the creator notes is a major shift in direction for Google's tooling.
• Multi-Model Support: One of the standout features is that agy isn't restricted to just Google's models. It provides access to various models, including Gemini 3.5 Flash, Claude Opus, and GPT-4o, making it a potentially versatile utility.
• Workflow Integration: The host demonstrates how they integrated Antigravity CLI into their own framework, Tank, which allows for a "multi-agentic" approach—essentially chaining different AI agents (like Claude Code, CodeEx, and Antigravity) to build and refine projects automatically.
• The "Quota" Trap: A major point of discussion is the strict usage limits on the free tier. Users have reported getting walled off after just 5–6 prompts. The creator notes that this is particularly confusing for Google Workspace users, as standard subscriptions often don't grant extra CLI usage, leaving developers hitting strict caps quickly.

Creator's Perspective:

The creator experiments with building a functional "Epic Snake" game using Antigravity CLI and discusses the "endgame" vision: a system where AI agents work in loops, handing off tasks to one another, switching providers to manage token usage, and ultimately self-improving code without needing constant human intervention.

While the multi-model access is a power move, the consensus from the stream is to approach the free tier with caution due to the aggressive rate limits, especially for those looking to build complex projects.

Watch the full deep dive here: https://www.youtube.com/live/kjFi1IuzWY4

What are you building today?

Update: Forgot to mention that to be fair and support `opencode` I plan to upgrade to their $10 /month plan.

I have successfully setup a combo of Antigravity + Opencode + Local LLM but I still believe there is a room for improvement. Please share if possible:

1. Ideas/tips to help me improve.
2. How much this setup is helping me save cloud tokens? Since we don't know the exact Google AI Pro qu*ta in absolute terms.

Details are below:

1. Setup MCP customization in Antigravity on Google AI Pro plan to share coding workload with Opencode (free plan) and Local LLM specifically the donkey work like searching and exploring local files, scanning logs, etc.
2. I am using Ubuntu WSL on Windows 11 to run Qwen 3.6 via LLAMA.cpp with Opencode and Antigravity installed in Windows 11.

Most recent task:

Here is a summary of the token usage and division of labor:

1. Division of Labor

* Antigravity (Cloud - Google AI Pro): Acted as the Manager. Architected the solutions, researched repository structures, generated the revised implementation/verification plans, and wrote detailed orchestration instructions.

* OpenCode (Local Agent): Acted as the Implementer. Executed the multi-file coding task to modify flow.js and flow_panel.html under explicit manager guidelines.

* Local LLM (ask_local - Qwen 32k on RTX 3090): Acted as the Inspector. Used for git commit analysis, file content analysis, and log reviews, keeping mechanical token queries off the cloud.

2. Approximate Token Breakdown

* Antigravity (Cloud): ~18,000 input / ~2,500 output tokens (high-level reasoning & planning).

* OpenCode (Local): ~15,000 local tokens (code modifications and git staging).

* Local LLM (Local): ~12,000 local tokens (inspecting codebases, git history, and summaries).

By routing code analysis and implementation to ask_local and ask_opencode, nearly 60% of the total token volume was processed locally on your RTX 3090 instead of consuming cloud qu*tas (`f**k mods for blanket filtering this word`).

Monitor running in WSL:

https://preview.redd.it/1hdh13u61a8h1.png?width=1193&format=png&auto=webp&s=0564c8203622c0acfe41d09a858c85f6e871c254

AGY Builders : Today marks the official launch of our subreddit following the end-of-life (EOL) of the Gemini CLI. We are building the future, one multi-agent at a time. The possibilities are endless with the Antigravity ecosystem, and we’ll be here Hassabing our way forward for future generations. I just want to reiterate that this community is yours, and I am the mod here to help you. Thanks for being with us in this amazing AGY future!

Share your best Antigravity Skills !!!! Is someone using Google's OKF format for the AGY skills

Today is June 18, 2026, and we are officially launching the r/AGYSkills subreddit! Please BYOD, and see you there!!!

AGY Builders,

As our community continues to grow, it’s amazing to see how we are pushing the boundaries of what the Antigravity CLI can do. To better organize our progress, we are officially splitting our focus into two distinct pillars: Infrastructure and Architecture.

To give both sides the dedicated space they deserve, we are launching a sister subreddit: r/AGYSkills.

🏛️ r/GoogleAntigravityCLI: The Infrastructure

The definitive home for how the tool runs.

Keep coming here for core technical discussions:

• Environment Setup: Terminal configurations and platform-specific setups.
• CLI Essentials: Command syntax, flag documentation, and version updates.
• Technical Deep-Dives: Authentication, environment variables, and advanced troubleshooting.

🧠 r/AGYSkills: The Architecture

The sandbox for what the tool can execute autonomously.

"Skills" are the modular logic that turns the CLI into an autonomous powerhouse. Head over to the new sub for:

• Prompt Engineering: Optimizing system prompts and execution logic.
• Workflow Design: Structuring YAML frontmatter and execution scripts.
• Community Library: Sharing, trading, and refining modular code blocks for specific tasks.

Why the split?

We want to keep r/GoogleAntigravityCLI laser-focused on stable infrastructure without burying core technical documentation under prompt scripts—and vice versa.

• Need your environment firing on all cylinders? r/GoogleAntigravityCLI
• Need to build or borrow autonomous workflows? r/AGYSkills

The doors are officially open on June 18 at 00:01 CST Head over, hit subscribe, and let’s start building the modular future of autonomous agents together!

See you there,

u/AgentPadrino — The Mod Team

r/GoogleAntigravityCLI & r/AGYSkills

Welcome to your new adventure r/GoogleAntigravityCLI

AGY Builders this is a big big big for us .... It will be the new format language for the Agents to share information

OKF is the future of the Agentic AI workflows according to Google. BYOD Bring Your Own Data

AGY Builders! Google’s Antigravity framework explained in plain English (Agents, Skills, Hooks, & Harness)

Let’s break down Google’s Antigravity framework into simple, everyday concepts that are easy to grasp. Here is a clear, jargon-free explanation of what Agents, Skills, Hooks, and the Harness actually do.

1. The Harness (The Secure Workshop)

• What it is: The Harness is the underlying foundation where everything runs. It provides the memory, the tools, and a safe, isolated box for the software to operate in.
• In Simple Terms: Think of it as a secure workshop. It’s the physical room equipped with tools, electricity, and heavy-duty walls. It ensures that whatever happens inside stays inside.
• Antigravity Context: When the AI needs to write a file or run a command, the Harness is the system that creates a locked-down, safe space for that action to happen. This ensures the AI can’t accidentally delete important files on your actual computer.

2. The Agent (The Smart Worker)

• What it is: The Agent is the autonomous brain (powered by an AI model) inside the Harness. Instead of you giving it step-by-step instructions for every tiny detail, you just give it a final goal. It plans the steps, does the work, and checks its own progress.
• In Simple Terms: Think of it as a highly capable worker. You don’t tell the worker how to swing a hammer or turn a screw; you just say, "Build a birdhouse." The worker gathers the wood, follows a plan, realizes they need smaller nails, goes back to get them, and finishes the job.
• Antigravity Context: You type: "Build a simple website." The Agent creates the files, writes the code, tests it, spots an error, fixes the bug on its own, and tells you when the site is ready.

3. Skills (The Instruction Manuals)

• What it is: If you give an AI every single rule and tool all at once, it gets overwhelmed and confused. Skills solve this by organizing information. They are specific folders of instructions that the Agent only reads when it realizes a task requires them.
• In Simple Terms: Think of them as task-specific instruction manuals. The worker doesn't memorize a massive encyclopedia of every job in the world. If they need to fix a plumbing issue, they grab the "Plumbing Manual" off the shelf. Once the pipe is fixed, they put the manual away.
• Antigravity Context: You have a special "Database Settings" Skill saved in your workspace. If you ask the Agent to format a text document, it ignores the database skill completely. But if you ask it to "pull the latest customer numbers," the Agent automatically opens the Database Skill, reads your specific rules, and gets the data.

4. Hooks (The Safety Guards)

• What it is: Hooks are checkpoints built into the system. They sit between the Agent's brain and the Workshop, allowing you to pause, watch, block, or change what the AI is about to do. They come in three types: Inspect (just watching), Decide (approve or block), and Transform (change the action).
• In Simple Terms: Think of them as safety guards or supervisors.
  • Inspect: A supervisor with a clipboard taking notes on everything the worker does.
  • Decide: A guard at the door. "Wait, the worker is trying to throw away a vital blueprint! Stop!" (Blocks the action).
  • Transform: A helper who takes the worker's finished piece and paints it blue before it goes out the door, because everything leaving the shop must be blue.

🧠 TL;DR

• Harness: The secure workshop where everything runs safely.
• Agent: The smart worker that figures out how to accomplish the goals you set.
• Skills: Specific instruction manuals the worker only picks up when a task requires them.
• Hooks: Safety checkpoints that let you watch, block, or alter what the worker is doing.

💬 What are your thoughts?

If you've been experimenting with Antigravity, how are you liking it so far? Do you think this structural approach makes building reliable agents easier, or do you prefer other setups? Drop your thoughts, questions, or use cases in the comments below

Welcome to your Skills hub for Antigravity. If you are building, tinkering, or designing custom AI agent behaviors, you have found your community.

r/AGYSkills is designed specifically for the creators and engineers pushing the boundaries of what autonomous agents can do. The "agents-first" era is here, and this is a collaborative hub for sharing and learning everything related to AGY skills, architectures, and workflows.

Why Skills Are the Core of Antigravity

In the Antigravity ecosystem (including r/GoogleAntigravityCLI, r/GoogleAntigravityIDE, or r/Google_Antigravity), an agent without skills is essentially just a passive chat interface.

Skills are what transform static models into autonomous operators. They represent the modular capabilities, toolsets, and discrete behaviors that allow agents to interact with systems, execute tasks, and make decisions.

Why do skills matter so much right now?

• The Shift to Composability: Instead of building massive, monolithic applications, the focus is now on engineering discrete, reusable skills that agents can dynamically call upon.
• Unlocking True Autonomy: Skills bridge the gap between a model's internal reasoning and real-world execution—whether that means interacting with local system environments, handling data pipelines, or utilizing external APIs.
• The Foundation of A2A: For complex Agent-to-Agent orchestration to succeed, agents must be able to understand what other sub-agents are capable of. Clearly defined skills act as the "API contract" between agents, allowing them to collaborate and hand off tasks seamlessly.

What Are We Building?

This space is dedicated to the technical side of the ecosystem. We want to see your work, whether you are:

• AGY Focus Skills: Building skills that align with our antigravity workflows.
• Exploring A2A: Crafting complex, multi-step Agent-to-Agent architectures that rely on skill hand-offs.
• Integrating MCP: Building tools and seamless workflows utilizing the Model Context Protocol to expand an agent's technical skill set.
• Pushing Open-Source: Dropping shell scripts, custom terminal configurations, and open-source agent behaviors. AGY community skills will be open-sourced from the AGY builders community to the wider AI Agent community.

What You Should Post

• Show and Tell: Got a new sub-agent skill working smoothly? Show us the repo, drop a terminal cast, and explain how you built it.
• Tutorials & Workflows: Share your step-by-step guides on optimizing agentic workflows and behavior design.
• Architecture Discussions: Let's debate the best ways to structure, scale, and register skills in multi-agent systems.
• Troubleshooting: Hit a wall with tool integration or behavior loops? Share your logs and let the community help you debug.

The Community Vibe

Keep it collaborative and open. We are all navigating this new frontier of AI development together. Share your successes, but also do not be afraid to post your broken code—that is exactly how we learn.

To kick things off, introduce yourself in the comments! What specific skills or autonomous behaviors are you currently building?

Let's build the future, one agent at a time (with multi-agent orchestration in the background).

AGY Builders,

I was inspired by yesterday's post about The Ultimate AGY CLI Anki Deck for Commands to keep creating content to master all things AGY.

We are doing the same with all the AGY concepts. Here is the breakdown:

⌨️ 1. Antigravity CLI (agy) (Fast speed TUI Command Center)

• 💬 Conversations: Navigating terminal sessions, using slash commands (like /rewind or /resume), and managing multi-step history.
• 🤖 Subagents: Running background agents to handle tasks without locking your terminal prompt.
• 📑 Artifact Review: Inspecting and approving file diffs directly within the console.
• ⏱️ Scheduled Workflows: Automating routines by integrating agent commands with system tools like cron.
• 📝 Skills: Writing declarative Markdown blueprints to define reusable agent workflows.
• 🪝 Hooks: Running local shell scripts before or after an agent executes a CLI command.
• 📦 Plugins: Bundling skills, hooks, and configurations into shareable packages.

🖥️ 2. Antigravity 2.0 (Desktop Command Center)

• 🔀 Parallel Agent Orchestration: Managing independent agents simultaneously through a standalone desktop interface.
• 📑 Artifact Review: Inspecting and editing files with a full visual review flow.
• ⏱️ Scheduled Tasks: Setting up automated background routines using built-in crons.
• 🎙️ Live Voice Transcription: Prompting agents using natural speech transcribed in real-time.

💻 3. Antigravity IDE (Agent-Powered Editor)

• ⚙️ Agent Manager: The built-in interface for configuring workspace-aware agents.
• 🧬 Native Context Injection: Feeding codebase maps and active errors directly to the agent.
• 🛠️ Inline Refactoring: Modifying code blocks directly inside your files.

🛠️ 4. Antigravity SDK & API

• ⚙️ Runtime Control: Initializing the agentic engine directly inside custom Python scripts.
• 🔧 Custom Tool Creation: Turning standard functions into executable tools for agents.
• 🧠 State Management: Saving and resuming agent histories programmatically.

🔐 5. System-Wide Fundamentals

• 🔌 Model Context Protocol (MCP): Connecting agents securely to external APIs and dev tools.
• 🛡️ Scoped Sandboxing: Setting directory boundaries and execution permissions per project.
• 🤝 Agent-to-Agent (A2A) Protocol: Enabling agents to delegate work and exchange structured messages.

AGY Builders, this community can't grow without you. Please grab an AGY concept and add to the discussion.

Thanks for being here and being awesome! 🚀

— Your AGY Mod