Since August 13th I've done nothing but test this thing.
Google dropped Gemini 3.7 Flash, and in the 24 hours before launch they pushed rapid updates to Antigravity 2.0, the IDE, the CLI, and the SDK. Three back to back updates to AGY 2.0 alone, and not small patches either. Actual feature work, stability fixes, and a level of polish that just wasn't there before.
I've been using Antigravity since the early days. Last time I gave detailed feedback, 2.0 was bare bones. It worked, but barely. The model at the time, 3.6 Flash, was functional but frustrating in ways that were hard to pin down. It ignored instructions, looped on broken approaches, burned through quota fast, and quietly skipped anything in your agents.md that didn't match what it had already decided to do.
That was three weeks ago. What shipped on the 13th feels different. Not flawless, but different enough that I want to walk through what improved, what's still rough, and what needs to happen next.
This is the biggest shift by far. 3.7 isn't an incremental bump over 3.6, it's a fundamentally more capable model. Having spent days in it, I'm honestly baffled by how limited 3.6 felt in comparison, that "how did I put up with that" moment you get when you upgrade something you didn't realize was holding you back.
Here's what actually changed in day to day agentic work, not on a benchmark chart:
It thinks about edge cases. 3.6 routinely missed obvious failure modes and shipped code that only handled the happy path. 3.7 catches null values, missing files, failed network calls. It self-checks what it just produced. That alone puts it in a different class.
It understands what you're actually asking for. With 3.6 you'd write a detailed prompt and get back something that covered maybe 60% of it, the rest filled in with the model's own guesswork. 3.7 reads the whole prompt and responds to what you actually said. Some of the outputs are surprisingly close to exactly what I had in mind.
Tool calling finally works properly. Every earlier Gemini model had rough edges here: malformed arguments, tools called out of order, tools ignored entirely, the same call repeated hoping for a different result. 3.7 sequences calls logically, picks the right tool, and actually reads the output before deciding what's next. For agentic work that's everything, since a model that can't call tools reliably can't really act as an agent.
It's cheaper to run. Partly thanks to the 50% introductory price cut Google shipped alongside launch (input at $0.75/m, output at $3.75/m through December 2026), but even adjusting for that, 3.7 uses less quota than 3.6 did. 3.6 used to burn more than 3.1 Pro, which in hindsight is wild. The efficiency shows up most in long agentic sessions that run for hours.
It changes approach instead of looping. This used to be the most painful part of using Gemini models. Try something, fail, try the exact same thing again, maybe a third time with a minor tweak before giving up or asking what to do. 3.7 will actually switch strategy after a couple of failed attempts and usually lands on something better the second time. That shift alone has saved me hours.
It actually follows your system prompt and agents.md. The worst thing about 3.6 was how aggressively it ignored your configuration. You'd carefully write out project conventions and architectural decisions and it just wouldn't read them, or would forget they existed a few turns later. 3.7 mostly fixes this. It's not perfect, in longer sessions with bigger scope it still starts drifting from the original instructions, but the baseline adherence is night and day.
This is where I see a real opportunity: some kind of persistent alignment layer that continuously checks what the agent is doing against the original prompt, the agents.md, and the defined scope. Right now the model starts strong and slowly wanders off. Something that keeps pulling it back to the rails would be a big deal.
Longer tasks hold together better. On extended multi step work, 3.7 stays coherent much longer than earlier models. It doesn't lose the thread five steps into a twelve step plan, and context retrieval is noticeably better too, it remembers earlier decisions and builds on them instead of rediscovering things from scratch.
It does real parallel work. When 3.7 kicks off a long running command, it doesn't just sit and wait. It finds something else useful to do while the command runs. Earlier models would launch a command and freeze until output came back.
One specific edge case worth flagging: if a long command is running and the model didn't set itself a reminder, and it's gotten deep into parallel work by the time that command finishes, it will sometimes just miss the completion notification entirely. This mostly shows up in long, context heavy conversations, but I've hit it more than once.
It hallucinates less. 3.6 would confidently invent file paths, function names, and error messages. 3.7 is more honest about what it does and doesn't know. It still hallucinates occasionally, that's just what these models do, but far less often.
This deserves its own section because I don't think enough people know it's possible.
In Antigravity you can run different models as subagents under a primary agent. In practice: I can have Claude Opus as my primary model and call Gemini 3.7 Flash as a subagent for a specific task. Flash does its work, reports back, and Claude continues from there. It works the other way too, run 3.7 Flash as the primary and have it spawn Claude or Gemini 3.1 Pro as subagents.
This isn't theoretical, I've been doing it daily. Claude orchestrating Gemini subagents, or Gemini orchestrating Claude subagents, all in the same session, all working on the same codebase, communicating through the platform's built in messaging.
The value here is real. Flash is fast for parallel subtasks, Pro is better for deep reasoning on hard problems, Claude brings a different coding style entirely. Mixing them inside one workflow sounds like it shouldn't work smoothly, but it does.
The subagent system is genuinely useful. You can define custom subagents yourself or have the primary model set them up based on what you need, then run several in parallel. A research agent can dig through docs while an implementation agent writes code while a testing agent validates it, real concurrent work.
The friction point is invocation. Right now the only way to spin one up is to ask the primary agent to do it, and the primary often forgets subagents exist at all, doing everything sequentially when it could delegate. A more direct trigger, a slash command or a UI element, would help a lot. There was a subagent UI shown in early demos that doesn't seem to be live yet. Possibly that's what /teamwork-preview is building toward.
AGY 2.0 shipped over 60 fixes, improvements, and new features across this update cycle. Three updates in rapid succession, and the app feels genuinely different from a few weeks ago.
Performance. Long conversations used to hang badly when opening. That's dramatically faster now. The sidebar, which used to lag with a lot of projects loaded, got real performance work. Hover tooltips on chat icons now appear instantly instead of after a delay that made you second guess whether you were even hovering the right thing.
Terminal visibility. You can watch running commands in the sidebar as they execute, live output, not just a consolidated view after the fact. Small design choice, big difference in how much you trust what the agent is doing.
UI polish. The ask a question panel is clearer, with the continue button only activating once you've actually answered. Media opens in a proper preview window. Feedback buttons no longer look permanently disabled. The project selector shows all your projects. Pin and unpin actually works on the first click instead of snapping back. Conversations can be grouped by project or status, and background automations show up under a scheduled tasks filter instead of disappearing. The hover card now shows the project name with a folder icon, and you can navigate action buttons by keyboard.
Stability. Agents were losing access to their built in helpers, fixed. Custom hooks were getting skipped before they could fire, fixed. Stopping a subagent now actually stops everything it spawned instead of leaving orphaned processes. Long answers used to jump back to the top mid read, fixed. Finished conversations no longer show as running after an app restart. Hooks that call a model now time out instead of stalling forever.
There's a pattern in these fixes: a lot of them are about things that used to fail silently or hang indefinitely. The app now fails loudly and recovers, which is exactly the right direction.
New capability. You can delete projects from settings, get side by side image previews (including SVGs) when comparing changes, sort conversations by last message time, use smarter slash command search, copy images to clipboard from artifacts, and local dev servers started by the agent are now reachable from the host machine, which was genuinely broken before.
Gemini 3.7 Flash performs noticeably better in AGY 2.0 than in the Antigravity IDE. Same model, same prompts, same kind of tasks. Tool calling is cleaner, command execution and output retrieval more reliable, reasoning more coherent in the app harness than the IDE's agent panel.
My guess is that the 2.0 harness is simpler, less noise in the system prompt. The IDE has a lot more moving parts, inline completions, code lenses, diagnostics, editor state, and all of that gets layered into what the model sees. More context, more room for confusion.
It makes sense that a model performs better in a harness built specifically for it, but the team should know that IDE users are getting a worse experience with the exact same model, and probably don't realize it.
These aren't vague complaints, they're specific and reproducible, with steps where I can give them.
Sidebar panel lag. The right side panel showing artifacts, media, running commands, subagents, and file diffs causes a serious hang when opened or closed. Every time, no exceptions. It's the kind of bug that makes you avoid a feature you actually need.
Ghost conversations. Reproducible: start a new conversation, type something, let the agent respond, then undo your only message. With no user messages left, the title placeholder disappears. The conversation stays in the sidebar as an empty, invisible slot. Hover over the list and you'll sometimes see it highlight. Click it and it opens, empty, but present. A phantom entry with no way to clean it up normally.
Terminal pollution across conversations. If one agent is running commands in one conversation and a second agent starts running commands in a different conversation entirely, their terminal output bleeds together. Both agents see output they didn't generate and get confused about which command produced what. Worse: I had two agents running commands at once, one hit Ctrl+C to kill its own process, and that Ctrl+C killed the other agent's command too. The other agent then sat wondering why its command never completed. I've seen this in both AGY 2.0 and the IDE, on WSL and native Windows. It looks like agents in different conversations are sharing the same terminal instance. They shouldn't be, each conversation needs its own isolated terminal or at minimum separated process groups.
WSL disconnects in the IDE. The IDE randomly loses its WSL connection mid session, not under heavy load, no clear trigger. You just get "Disconnected from WSL" and a reload prompt, and reconnecting doesn't cleanly restore state. After reload, a thin colored line (yellow or green) shows up at the bottom of the screen and won't go away until you restart the entire PC, not the IDE, the whole machine. Only happens after a WSL disconnect followed by reload.
WSL execution in AGY 2.0. More of a structural gap than a bug. AGY 2.0 runs natively in PowerShell on Windows, with no native way to switch its terminal to WSL. Every command has to route through wsl.exe as a prefix. The moment you're running Linux commands through that bridge, performance drops, tool calling gets rougher, terminals get stuck. Same underlying issue the IDE has had, unfixed in both places.
Media attachment bug. Sometimes clicking attach, picking a file, and hitting enter just does nothing, and no amount of retrying fixes it. Workaround: attach a different file first, remove it, then attach the one you wanted. Then it works.
Network stalling, possibly the most frustrating one. On a slow or unstable connection, AGY 2.0 doesn't slow down, it stalls completely. You send a prompt and it sits on "Working..." for hours with zero progress, no partial output, no timeout, no fallback. Agentic work needs a stable connection to the API, understood, but there should be timeouts, retries, or at least some signal that the connection is struggling instead of hanging forever.
This section isn't complaints, it's where I think Antigravity should go next.
1. Accessible from anywhere. Right now Antigravity lives entirely on the desktop. If you're not at your computer, you have zero visibility into what your agents are doing. That needs a real mobile experience, not a workaround, an actual way to check status, approve something, or send a follow up from your phone. A web client too, so you can pick up exactly where you left off from any browser. Longer term, I want this to be remote first: desktop, laptop, browser tab, phone, home server, cloud VM, all just different windows into the same workspace.
2. Cloud agents and cost visibility. There's a real difference between an agent working on your machine and an agent working independently in its own environment. I'd like isolated, managed cloud sandboxes where an agent can clone a repo, install dependencies, run tests, use a browser, commit, and report back. Dispatch five tasks without worrying whether your laptop can handle it. And once cloud agents are real, I want per agent, per task breakdowns of model used, tokens, time, tool calls, and cost, so you can match cheaper models to simpler tasks. Per task model selection for scheduled automations would make this a lot more practical too.
3. Smarter orchestration. Explicit handoffs between agents would help a lot, one agent investigates a bug, hands context directly to an agent that fixes it, which hands off to one that tests it, without re-explaining everything from scratch each time. Beyond that, a real control plane: a single view of what every agent across a project is doing, which ones are blocked, which need approval, what changed. As agent count grows, managing them as a fleet instead of a pile of chat tabs becomes necessary. Terminal and workspace visibility needs to scale with it too, which workspace and worktree each agent owns, which branch, which ports are active.
4. Persistent memory and deeper git integration. One of the most annoying parts of agentic development is watching a new agent rediscover something a previous one already figured out. I want actual long term project knowledge, architectural decisions, conventions, weird bugs already investigated, libraries deliberately avoided, that survives across agents and sessions. Coming back to a project six months later and having it still understand why the codebase looks the way it does. Git integration should go deeper too: take an issue, spin up an isolated workspace, implement the change, run tests, open a PR, respond to review comments, iterate, as one continuous flow rather than "the agent can run git commands." The same for CI, if a build fails, get the logs, reproduce it, fix it, rerun tests, report back on its own.
5. Event driven automation and programmability. Scheduled tasks are useful, but the model is still "run this at this time." I want "run this whenever this happens", an issue appears, CI fails, a file changes, a deployment breaks, a PR sits untouched for a day. That's the difference between scheduling prompts and building actual autonomous workflows. On skills, I'd love the ability to demonstrate a workflow once and have Antigravity turn it into a reusable skill by watching the sequence, rather than writing configuration by hand. And eventually a real API for the system itself: create an agent, attach a workspace, send a task, check status, approve something, pull the diff, stop it, resume it, all programmatically.
6. Permissions, safety, and reversibility. As agents get more autonomous, granular permission control matters more, filesystem, network, credentials, browser, shell, deployment access, scoped per agent based on what it's actually doing. And agents will make mistakes, so I want a clean way to roll an autonomous run back to the exact state before it started, ideally with the ability to keep some changes and discard others selectively. I'd also love to see Antigravity become a kind of universal agent layer, bringing in Claude Code, Codex, or other local agents into the same workspace, not because Google's own agent isn't good, but because different agents are good at different things.
I'm writing thousands of words about bugs and feature requests because I think what the Antigravity and DeepMind teams are building actually matters.
Three updates to AGY 2.0 in 24 hours. A model that jumped from 49% to 65% on DeepSWE in a single generation. A 50% price cut that makes extended agentic sessions actually affordable. That's not maintenance, that's a team shipping with intent.
Gemini 3.7 Flash is a turning point for the Gemini family, the first Gemini model I've genuinely enjoyed using for agentic work instead of fighting. It thinks, adapts, follows instructions, calls tools properly, and does it all at a price point that makes sustained use practical. That combination didn't exist before August 13th.
But the work isn't finished. Terminal isolation, WSL stability, network resilience, sidebar performance, these aren't nitpicks, they're the things that decide whether developers adopt this as a primary workflow or just check in on it occasionally.
To the Antigravity and DeepMind team: the foundation is right, the model is right, the building blocks around subagents, skills, hooks, and scheduled tasks are the right ones. Don't let rough edges hold back what this can clearly become.
I might be wrong about some of this, and I'm happy to be corrected. Some of these bugs could be specific to my setup, and some of these feature requests might already be in progress. This is just what I ran into and what I think would make it better.
I've also been building real projects with 3.7 Flash during this testing period. A separate post is coming showing what I built, the workflow I used, and what the model can actually do when everything clicks.
Thanks to everyone on the Antigravity and Google DeepMind teams for the work so far. The pace here is real, and a lot of us are rooting for you.