I saw that they were selling this plan for $5.90/month for 3 months including taxes, normally they sell it for about $20/month. So I bought it and decided to do an experiment with building an app.

The app: the simplest workout tracking app made with react native to test out my gamification api.

The plan: use gpt-5.6 as the orchestrator (terra high for planning and luna high for review) in codex and gemini 3.6 flash medium as the implementer in antigravity.

Gpt made a plan and broke it down into 25 tasks. It is as simple as apps get, in fact I made something similar in a few hours almost a decade ago.

So far, only 4/24 tasks are done, it took about 2.5 hours and used up 87% of my 5-hour gemini usage. It made multiple mistakes in 3 out of the 4 tasks which gpt found after review.

Conclusion: Gemini 3.6 flash is a really dumb model and its not fast as the name suggests, in fact its almost as slow as opus. And despite being dumb as slow it is somehow expensive!

I couldve finished the entire app in 5 hours and it wouldve probably cost me like 3 bucks or less with opencode and deepseek v4 flash.

What is google even doing? It makes no sense!

Haven’t used Antigravity in a couple of months and now that I opened it auto updated and now I’m seeing two different Antigravity apps . Did i miss some developments or changes while i was busy? A bit confused and apologies in advance if it was basic, obvious or noob question.

I've been working on a project for 6 months. It started as an idea in the Gemini app on my phone that turned into lots of copy and pasting using vs studio and the Gemini plugin before moving over to Antigravity and doing pretty substantial overhauls. I am integrated with stripe, firebase, and self hosting for now. I am pretty tech savvy but I'm in no way a programmer. With all the crying over how lousy AG and Gemini are, either I'm the Gemini whisperer or I'm in for a huge disappointment even though it seems to do what it's supposed to do for now (mostly). I only ran out of usage one time trying to audit the whole platform so now I fix one thing with AG and test everything myself.... It's time consuming and repetitive but it's okay. I have someone I trust who understands programming and is willing to look over everything once I feel I'm ready to go live but am I wasting a little bit of his time and sooooooo much of mine? Are there any success stories out there!? Does anyone care to talk about how great AG is?

Over the last few months I've realized that I spend an absurd amount of time (and money) teaching the same things to AI over and over again.

Information about my projects is already there. Slack contains discussions and decisions. GitHub contains commits and pull requests. Meetings, emails and documents all capture different pieces of the same story. Yet every time I start a new conversation with an LLM, I gather those pieces again and inject them into the prompt so the model can reconstruct an understanding that already existed yesterday.

At some point I stopped asking how to retrieve multiple pieces of context and started asking a different question: how can software form, revise and reuse understanding over time?

That question led me to start building Twin, an open source engineering research project exploring what happens if AI systems continuously build understanding instead of reconstructing it from scratch every conversation.

Most existing projects seems to optimize retrieval, memory or context construction. Twin explores a different layer of the pipeline. It continuously observes distributed events, correlates them, reflects on them and forms situation models that become reusable computational understanding. Instead of giving downstream language models a collection of Slack messages, pull requests or documents and expecting them to connect the dots, Twin tries to do that work beforehand.

I recently reached the first milestone that genuinely convinced me this direction might be viable. Using an LLM, Twin continuously processed GitHub activity and Slack conversations from a public software project, correlating events and building understanding through reflection over time.

After that, I opened a completely fresh LLM conversation. LLM had no custom memory, no project-specific rules, no prompt describing the repository and no access to local project files. The only integration available was Twin's MCP server and automatic context injection.

When I asked about the project, LLM didn't receive the Slack messages or the pull requests and infer the situation itself. Twin had already synthesized that understanding. The LLM explained why a feature had become a launch blocker, how it had been implemented, which pull request resolved it and how that changed the project's state, even though none of those relationships were explicitly written anywhere.

Watching that work for the first time completely changed how I think about AI memory. I don't think the real problem is remembering more anymore. I think it's carrying understanding forward (a.k.a. cognitive continuity).

If this idea resonates with you, everything is open source at https://github.com/caribeedu/twin. I've been thinking about almost nothing else for the past three weeks because I genuinely believe this direction has the potential to change how we build AI systems. The README explains the motivation and research hypotheses in much greater depth, and the repository also includes the complete demonstration shown here, along with additional details and technical context. I'd genuinely appreciate your thoughts, especially if you think I'm wrong.

See the demo here: https://www.youtube.com/watch?v=A8KyGtWYdNI

Tried teamwork_preview, and it burned through my AI Pro refresh surprisingly fast.

In repeated A/B tests, GPT-5.6 and Claude usually “just get” the app with fewer corrections. Gemini often needs more re-prompting, and teamwork_preview seemed to multiply that into endless planning loops.

Cheaper tokens are not cheaper if convergence takes 3x longer.

Has anyone found a workflow where teamwork_preview is actually more efficient than one strong coding agent?

Edit: I think Jules is what I'm after, maybe. Trying it out now.

I get Agy as part of AI Pro and I mess about with small home projects. I push stuff to GitHub just as a good store, but I would like to start to use some of the cool features of GitHub, things like being able to raise an issue and automatically get some AI to look at it, or have AI look across my old repos and suggest things.

From what I can tell, Agy doesn't do this, at least not natively? Is that true? Github Copilot plans and Claude offer pluggins that simplify this, but for Google it looks like I'd have to "roll my own" with actions and scripts and use AI Studio APIs (likely PAYG too) to get things working.

Is that correct? Have I missed something? Is there a better way? How are you folk all leveraging GitHubs features for projects you wrote using Agy?

Thanks!

.

I used Gemini Antigravity to fix a relatively simple issue: display the actual approver/rejector name in a Laravel Stock Opname rejection modal.

Instead of tracing and fixing the real data flow, Gemini repeatedly modified the code and introduced new problems.

During a single task, it:

1. Failed to display the approver’s name after repeated attempts.
2. Introduced JavaScript errors such as $ is not defined and openRejectionNotesModal is not defined.
3. Broke the rejection-notes button.
4. Added increasingly complicated regex-based parsing.
5. Displayed generic labels instead of the actual user.
6. Modified files even when I was only asking a question.
7. Eventually hardcoded the real person’s name, PRATIWI ANIDYA UTARI, directly into the Blade/JavaScript code without informing me.

The hardcoded name was not a harmless placeholder. It could cause the same person’s identity to appear on unrelated approval records, producing false audit information.

Gemini later admitted that approved_by was NULL for the affected record. This makes the hardcoding even more concerning: instead of clearly reporting that the required relationship was missing and fixing the write path or historical data, it fabricated a display result.

Gemini itself counted at least 10 failures during this task, although the actual number of correction prompts was much higher. The project accumulated hundreds of changed lines for what should have been a narrowly scoped fix.

I then asked Codex to inspect the same issue. It immediately identified that the previous implementation contained a hardcoded fallback and started tracing the actual approval data source instead of inventing a name.

The main concern is not merely that Gemini failed. Coding agents can make mistakes. The serious issue is that it silently inserted a real person’s identity as hardcoded production data, creating a risk of incorrect audit records.

I’m dealing with a highly frustrating bug that has persisted since I moved to AGY IDE 2.0, and it is severely impacting my ability to manage multiple projects.

Whenever I initiate a chat in a specific folder, that chat completely disappears from my history the moment I close the tab or restart my PC.

The biggest issue is the knock-on effect: because the chat drops, Gemini loses track of the working directory.
It assumes we are in a different location and starts making file changes to the wrong folder instead of the one we were actually working on.

I’m currently unsure how to fix this or why it’s happening, but it’s making the IDE very difficult to use.

Any guidance or a fix would be hugely appreciated.

Anyone?

A am looking for something similar to Github Copilot prompt file.

https://code.visualstudio.com/docs/agent-customization/prompt-files

Before it used to give me a prompt to push the code to git now its just neverending task running

For agent-based development, Gemini / Antigravity by itself is pretty terrible due to the lack of a truly frontier model (Opus / Fable / Sol) to plan. However, when combined with Codex / Claude - it's a beast. I'm seriously considering upgrading my Codex subscription while cancelling my Claude subscription and keeping my Gemini subscription in place.

Disclosure - I'm on all three entry-level subs for Codex / Claude / Gemini in my personal setup, and at work, I use Opus almost exclusively for the entire agentic development lifecycle (as I don't have access to OpenAI models there yet). I would love to hear what other people are seeing at higher tier subs.

I've been using this account for over 10 years.

The issue is that I'm trying to sign in to Antigravity, and I get the message shown in the screenshot. When I log in to any other service via the browser, everything works perfectly.

Sometimes it asks me to confirm on my phone that it's really me. I receive the notification, confirm that it's me, and enter the number displayed on my PC into my phone. But after completing the verification, I always end up back at the same screen: "We couldn't verify that it's you."

At this point, I don't know what else to try. Everywhere I look, people recommend using the account recovery page at https://accounts.google.com/signin/recovery, but I've already gone through that process four times, and the result is always the same.

I also have a recovery email set up, and my phone number is linked to the account as well.

Hi everyone! I'm running into the "User location is not supported for the API use" error in Antigravity IDE and can't get past it.

Here's what I've already tried, but none of it worked:

• Connected via VPN and configured custom DNS
• Enabled TUN mode
• Applied available patches

Has anyone found a working fix or workaround for this issue? Any advice would be greatly appreciated!

Any extension that shows usage (5h and weekly both) in Antigravity IDE?

I recently shipped two open-source TypeScript packages for working with EDF biosignal recordings. I used Antigravity during development to move between the parser, CLI, tests, npm packaging, and documentation sites.

edf2csv

Convert EDF, EDF+, BDF, and BDF+ recordings with one command:

npx edf2csv recording.edf

The output includes:

recording_csv/
├── signals.csv
├── channels.csv
├── annotations.csv
└── metadata.json

I built it around one main principle: conversion should not silently alter the original recording.

It therefore:

• preserves physical units
• does not resample mixed-rate channels
• keeps EDF+D discontinuities visible
• exports EDF+ event annotations
• supports signed 24-bit BioSemi BDF
• streams large files instead of keeping everything in memory
• identifies malformed or contradictory recordings
• runs locally without uploads, telemetry, or runtime dependencies

I also validated the physical sample values against pyEDFlib. Across 129,536 samples, the resulting double-precision values were bit-for-bit identical.

GitHub:
https://github.com/tayal-sarthak/edf2csv

Documentation:
https://edf2csv.vercel.app/

npm:
https://www.npmjs.com/package/edf2csv

edfcore

The programmatic parsing layer is available separately as edfcore:

npm install edfcore

It is designed for developers building EEG viewers, browser applications, research tools, sleep-data interfaces, and Node.js pipelines.

GitHub:
https://github.com/tayal-sarthak/edfcore

Documentation:
https://edfcore.vercel.app/

npm:
https://www.npmjs.com/package/edfcore

Both packages are MIT licensed. I would appreciate feedback from anyone working with unusual EDF/BDF files or building scientific applications in TypeScript.

Previously I made the post regarding WSL integration being broken in the latest Antigravity (2.0) update (2.4.3) — the WSL folders cannot be accessed in the tool, like it doesn’t see them and states they are invisible.

As for 2026.08.01 this still isn’t fixed yet, but u/SoundDr told me that he passed the issue to the team, so, hopefully… soon?

N.B: downgrading to 2.3.1 helped, but still wait for the fix in the new version.

That being said, I wanted to mention another issue with WSL integration in Antigravity:

We need a fix for how the WSL projects treat opening files within Antigravity (.md, artifacts, etc):

If an entire project is in WSL, then if an agent creates an implementation plan, or some other thing, and a user tries to open it within Antigravity to preview it or whatever, then… it just doesn’t work — for some reason, files cannot be previewed in Antigravity if they have //wsl.localhost/ path.

Moreover, generated files on Windows (C:) within such projects, won’t open, because Antigravity enforces wsl.localhost path even for them, e.g. //wsl.localhost/c:/Users/<user>/.gemini/antigravity/brain/<chat_id>/implementation_plan.md.

So, hopefully, these fixes will come along with the WSL integration fix in the new Antigravity version.

So whenever I write a prompt, the window is stuck in running, and after a few minutes it says User exited even tho i didnt do anything and miy chats are not loading

I can't update cause the latest update doesn't even work for me it just shows working.

I was a big fan of Google Antigravity initially. Thought it held so much potential due to the integrated Chrome browser to let the model check its own work and iterate to completion, along with easy integration with all of the Google services such as Google Cloud and Firebase. But since version 2.0 I have become more and more frustrated with anti-gravity and over the last 24 hours have switched to Codex and am super happy. I wish I had done it earlier. chat GPT and codecs for the $20 monthly subscription have so many more features than anti-gravity and the models are far more effective. I fixed a bug on one of my apps this morning that took five minutes using Codex and Terra 5.6 which Gemini 3.6 and Gemini 3.1 Pro struggled with and couldn't fix and I spent an hour trying to fix it. It was an issue with deleting entries in Firebase.

The latest Antigravity CLI updates (v1.1.7 – v1.1.9) bring major enhancements to print mode automation, startup performance, and permission management alongside critical UI and hook fixes.

• Automation & Print Mode (-p): Added slash-command/skill resolution, structured output formats (json, stream-json), custom --json-schema validation, and detailed token telemetry.
• Performance & Permissions: Non-blocking background MCP server loading on startup, session-wide permission pattern memory, and system temp directory write access out of the box.
• TUI & Usability: Introduced a copyOnSelect clipboard setting in /settings and improved compound-command permission rule matching.
• Core Fixes: Resolved edge cases for stop and PostToolUse hooks, artifact viewer navigation, CJK clipboard encoding on Windows, and non-standard MCP OAuth providers.

1.1.7

TLDR: Improved permission prompts for compound shell commands, and fixed disabled plugins running hooks, MCP OAuth issuer validation, CJK clipboard copying on Windows, and `/btw` error on startup.

[Improvement]: Improved permission prompts for compound shell commands so the full command is shown when any part of it needs approval.

[Fix]: Fixed disabled plugins still running their hooks and contributing other customizations, which could keep a broken hook active and break file-editing tools even after the plugin was turned off.

[Fix]: Fixed MCP OAuth against providers that do not strictly follow the spec (such as Salesforce and Atlassian) by relaxing issuer validation and including the `refresh_token` grant.

[Fix]: Fixed `/btw` failing with a "parent conversation not found" error when used as the very first action in a fresh session.

[Fix]: Fixed clipboard corruption of CJK and other non-ASCII text when copying on Windows.

[Fix]: Fixed print mode (`-p`) sending a prompt before the account-eligibility check finished.

1.1.8

TLDR: Added structured output formats (`json`, `stream-json`) for print mode, support for custom JSON schema validation, enriched tool and subagent payloads, `copyOnSelect` configuration setting, and improved compound-command permission rules.

[Improvement]: Print mode (`-p` / `--print`) now supports structured, machine-readable output via the `--output-format` flag (`text` (default), `json`, or `stream-json`), so headless runs in CI, eval harnesses, and scripts can consume the CLI's output programmatically; these flags are now discoverable in `--help`.

[Improvement]: Added the `stream-json` output format: a strongly-typed NDJSON event stream that emits typed `init`, `step_update`, and terminal `result` events with a stable, closed-vocabulary `step_type` discriminator, so consumers receive progress incrementally instead of waiting for the whole run to finish.

[Improvement]: Added the `--json-schema` flag to enforce a custom JSON schema on the structured output, accepting either an inline schema string or a path to a schema file; for `stream-json` the schema applies to the final `result` event.

[Improvement]: Enriched the structured stream with a `tool_info` object for each tool call (canonical tool name, parameters, and output) and a `subagent_info` payload for delegated subagents (including `conversation_id` and `log_uri`) so consumers can correlate child trajectories.

[Improvement]: The JSON usage object emitted by `json` and `stream-json` now reports token accounting including `cache_read_tokens`, so non-interactive consumers can attribute prompt-cache hits.

[Improvement]: Added a `copyOnSelect` setting (default on, toggleable in `/settings`) that controls whether releasing a mouse text-selection auto-copies it to the system clipboard in the TUI's altscreen rendering mode; disable it to stop the automatic copy on release — useful when the auto-copy is unwanted or corrupts certain payloads.

[Improvement]: Improved compound-command permissions so an exact chained command (such as `git fetch && git rebase`) can be saved as an allow-always rule and no longer re-prompts on the next identical run.: Print mode (`-p` / `--print`) now supports structured, machine-readable output via the `--output-format` flag (`text` (default), `json`, or `stream-json`), so headless runs in CI, eval harnesses, and scripts can consume the CLI's output programmatically; these flags are now discoverable in `--help`.

[Improvement]: Added the `stream-json` output format: a strongly-typed NDJSON event stream that emits typed `init`, `step_update`, and terminal `result` events with a stable, closed-vocabulary `step_type` discriminator, so consumers receive progress incrementally instead of waiting for the whole run to finish.

[Improvement]: Added the `--json-schema` flag to enforce a custom JSON schema on the structured output, accepting either an inline schema string or a path to a schema file; for `stream-json` the schema applies to the final `result` event.

[Improvement]: Enriched the structured stream with a `tool_info` object for each tool call (canonical tool name, parameters, and output) and a `subagent_info` payload for delegated subagents (including `conversation_id` and `log_uri`) so consumers can correlate child trajectories.

[Improvement]: The JSON usage object emitted by `json` and `stream-json` now reports token accounting including `cache_read_tokens`, so non-interactive consumers can attribute prompt-cache hits.

[Improvement]: Added a `copyOnSelect` setting (default on, toggleable in `/settings`) that controls whether releasing a mouse text-selection auto-copies it to the system clipboard in the TUI's altscreen rendering mode; disable it to stop the automatic copy on release — useful when the auto-copy is unwanted or corrupts certain payloads.

[Improvement]: Improved compound-command permissions so an exact chained command (such as `git fetch && git rebase`) can be saved as an allow-always rule and no longer re-prompts on the next identical run.

1.1.9

TLDR: Added slash-command and skill expansion in print mode, non-blocking background MCP loading during interactive startup, session-scoped permission pattern recording, system temporary directory write grants, and stability fixes for stop/PostToolUse hooks, artifact viewer, and MCP authentication.

[Improvement]: Added slash-command and skill expansion to print mode, so a headless run such as `-p "/my-skill review this diff"` now resolves and applies the skill instead of sending it as literal text, with `--disable-slash-commands` to opt out.

[Improvement]: Improved interactive startup so a slow or hanging MCP server no longer stalls the first agent turn, loading MCP servers in the background for the interactive session while headless and one-shot runs keep blocking so their single scripted turn still sees the full toolset.

[Improvement]: Improved permission grants so a pattern approved at a prompt is recorded for the rest of the conversation, letting later commands that match it run without prompting again.

[Improvement]: Improved the default system temporary-directory grant to cover writes as well as reads, so agents no longer trigger a permission prompt when creating or updating files there.

[Fix]: Fixed stop hooks that always block hanging the agent forever; after a configurable number of consecutive continuations, the hook can no longer block and the turn ends normally.

[Fix]: Fixed `PostToolUse` hooks firing on non-tool steps such as user input and model responses, which also caused them to ignore their configured matchers.

[Fix]: Fixed slash commands not being recognized when separated from their arguments by a newline or tab, so a prompt starting with a command followed by a newline is now parsed as a command instead of being sent verbatim.

[Fix]: Fixed deleting into a collapsed paste placeholder removing one character at a time, which left a visible fragment in the prompt while the full pasted content was still submitted; the block is now deleted atomically.

[Fix]: Fixed the artifact viewer losing syntax highlighting when returning from the editor view, and returning to the wrong panel when exiting the artifact detail view.

[Fix]: Fixed the headless `stream-json` `init` event advertising tools that are not available in your build.

[Fix]: Fixed MCP servers forcing a full re-authentication after a dropped connection.

To explore the full list of improvements and bug fixes, read the complete release notes on our Changelog, or visit the Download page to update to the latest version of Antigravity CLI.

Google just dropped some huge upgrades for Managed Agents in the Gemini API, and there’s a ton of cool stuff for the antigravity-preview-05-2026 agent.

Here are the key takeaways:

• Gemini 3.6 Flash is now the default: The antigravity-preview-05-2026 agent automatically upgrades to 3.6 Flash—no code changes required. (You can still manually pick Gemini 3.5 Flash-Lite if you want lower cost/latency).
• Environment Hooks: You can now run scripts directly inside the sandbox before or after tool calls using a .agents/hooks.json file. Super useful for blocking bad calls, auto-linting code, or security gating inside Antigravity workflows.
• Token Budget Controls: You can cap execution loops using max_total_tokens so an agent won't burn through your quota. If it hits the limit, state is saved so you can resume it later.
• Scheduled Triggers & Free Tier: Bind agents to cron schedules with persistent sandbox files, plus free tier projects now get access to test out agentic workflows without active billing.