Google Antigravity + Gemini 3.7 Flash: The Leap from Writing Code to Delivering Results

From "Writing Code" to "Getting the Job Done"

For a long time, AI coding tools have left a familiar impression: they generate a piece of code that looks decent, then disappear — leaving you to run the tests yourself, fix the bugs yourself, and verify whether it actually works in the browser yourself. According to hands-on demos by Bilibili creator Peep, Google's newly released Gemini 3.7 Flash is trying to change that.

Its core positioning is no longer a conversational companion, but a "primary workhorse model" built specifically for coding and Agent (autonomous AI) scenarios. More importantly, Google didn't just drop it into a chat window in isolation — it's been directly integrated into a development platform called Antigravity. In plain terms: the AI can go finish the work in a project on its own — writing code, running tests, reading error messages and auto-fixing bugs when they appear, then verifying the results in a real browser, all without you hovering over it.

This "end-to-end delivery" capability is the real upgrade here — quietly understated, yet carrying serious weight.

Gemini 3.7 Flash Performance: How Much Did Three Weeks of Iteration Actually Deliver?

What makes this interesting is that Gemini 3.7 Flash arrived just three weeks after its predecessor, 3.6 Flash — an astonishingly fast release cadence. So is this a genuine upgrade, or just a shiny new version number? The benchmarks give a clear answer.

Major Gains in Coding Ability

• On the Frontier Code programming benchmark, the old model scored 34.4%; the new model jumps to 43.6%;
• On the Deep Squeeze test, the old model scored just 49%; the new model leaps to 65.3%.

Given the three-week gap, that kind of improvement is genuinely rare. Google emphasizes that these gains show up in what actually matters day to day: fixing bugs, solving real problems, and writing code that works the first time.

A note on these benchmarks for those less familiar: Frontier Code measures a model's ability to tackle complex, cutting-edge programming problems — typically involving algorithm design, systems-level code, or real-world engineering scenarios. Jumping from 34.4% to 43.6% means the model is now passing nearly 30% more of the hardest problems. Automation Bench is closer to real office work, testing whether a model can independently complete multi-step business workflow tasks — parsing tables, filling forms, triggering workflows — tasks that require both contextual understanding and reliable tool use. It measures practical utility rather than raw intelligence. A score of 30.4% may look modest in absolute terms, but compared to the old model's 17% baseline, it represents a qualitative leap — and also shows just how challenging these tasks remain for all current models.

Knowledge Work Benefits Too

Easily overlooked is the fact that this upgrade isn't limited to coding. On Automation Bench, which measures real-world business workflow tasks, the old model scored just 17% while the new model hits 30.4% — nearly double. This matters, because real work isn't all code. There's a mountain of reading, document organization, and workflow handling — the kind of "invisible" tasks that quietly eat your entire afternoon. A model that's better at handling documents and processes can genuinely give you time back.

The Core Agent Mechanic: From "Gets Stuck and Stops" to "Adjusts and Tries Again"

For Peep, the Agent functionality is the most compelling part of this update. Gemini 3.7 Flash operates in a closed loop:

1. Plan first upon receiving a task;
2. Edit files, run code, test the code;
3. When something goes wrong, don't give up — instead adjust, fix the errors, and confirm the final result;
4. If it didn't work, try again.

The key word here is Adjust. The old model would hit a snag and simply stop, leaving behind a half-finished product with no clear indication of what went wrong. The new model keeps trying — fixes first, then checks whether the fix worked, and if not, tries again. This is the fundamental difference between "an AI that assigns you homework" and "an AI that actually delivers finished work."

According to the demo, a user only needs a single line of input — something like "build a clean resources page for this site, make it clear what members get, and make sure it works on mobile" — and the Agent will automatically parse the requirements, build the page, test it in the browser, and leave you only needing to review the final version.

The term "Agent" (or AI Agent) appears frequently and is worth clarifying. An AI Agent is an AI system that can perceive its environment, autonomously plan steps, and take a series of actions to accomplish a goal — distinct from the passive "one input, one output" model of standard chat AI. Regular models wait for your next instruction after each response. Agents are different: given a goal, they break it into steps, call tools (such as executing code, reading/writing files, or opening a browser), observe the results, and decide what to do next — forming a continuous "perceive → decide → act → feedback" loop. This is why "Adjust" is so critical: only a loop with self-correction capability can truly see a task through from start to finish, rather than stopping at the first obstacle and kicking the ball back to the user.

Inside Antigravity: A "Command Center" for Your Agent Team

Antigravity isn't a standalone app. Looking back at Google I/O, it launched as Antigravity 2, composed of multiple parts — think of it as a control room that lets you run and direct an entire squad of Agents at once:

• Desktop app: centrally coordinates multiple Agents;
• Terminal execution: run Agents directly from the command line;
• SDK: developers can build and customize their own Agents;
• Coding environment: built-in Agent manager.

Three New Features That Actually Matter

Beyond the core framework, a few new additions are especially worth noting:

• Sub-Agents: the primary Agent can delegate portions of a task to helper Agents for parallel work — one handling page construction, another handling compatibility checks — preventing a single Agent from bottlenecking the whole process;
• Scheduled tasks: let Agents run automatically in the background without requiring constant human supervision;
• Voice commands: issue instructions to Agents by speaking, rather than typing everything out.

When Google puts a more powerful brain like Gemini 3.7 Flash into a system specifically designed to "make Agents actually do the work," what you get is no longer a smarter chatbot — it's a small team you can direct.

The SDK (Software Development Kit) mentioned here refers to a set of programming interfaces and libraries Google provides, allowing developers to build custom Agents on top of Antigravity without having to design the underlying orchestration logic from scratch. The Sub-Agents concept is also worth unpacking: this is a "primary-subordinate" architecture where the main Agent handles overall planning and task decomposition, distributing subtasks to multiple specialized Agents for parallel processing before aggregating the results. It's conceptually similar to a microservices approach in software engineering — each Agent handles only what it does best, improving the overall system's reliability and speed. For non-developer users, this means complex tasks (like simultaneously building a page, checking compatibility, and generating documentation) no longer need to run in serial — multiple Agents can tackle them in parallel, concurrently.

A Grounded View: Where Are the Limits?

Despite the impressive capabilities, Peep is candid about realistic boundaries: we're not yet at the stage where you can throw an entire project at the AI and walk away.

You still need to: review the results, set the direction, and stay clear on who this work is for. AI can make the whole process dramatically faster, but it can't think for you — it's a powerful tool, not a replacement for you.

Practical Tips for Getting Started

For anyone who wants to try this out, here are a few grounded suggestions:

• Start with small tasks: don't begin with your biggest project. Have it build a single-page layout or a specific fix first — something where you can immediately tell whether it succeeded;
• Watch how it thinks: don't just look at the output. Watch how it works through each step, and you'll quickly learn what it's good at and where it needs more explicit guidance;
• Treat it like a new teammate: don't expect it to get everything right on the first try. Give it tasks with clear "done" criteria.

The people who get the most out of these tools aren't the ones with the most elaborate setups — they're the ones who learned how to clearly hand off a task and quickly evaluate the result. That "assign → review" feedback loop is the core working rhythm of the AI Agent era.

Closing Thoughts

The combination of Gemini 3.7 Flash and Antigravity marks a pivotal step in AI's evolution — from "code completion assistant" to "autonomous task executor." The three-week release cadence, benchmark scores that roughly doubled, and system-level capabilities like Sub-Agents and scheduled tasks all point in the same direction: AI is shifting from passive response to active delivery. But the more powerful the technology becomes, the more important it is for humans to stay clear-headed — deciding what to do and for whom remains a part of the job that can never be outsourced.