Gemini 4 Argon Overnight Run: 11 Hours on 200k Lines

Most coverage of Gemini 4 Argon has focused on benchmark tables. We covered those in our launch review and in the follow-up on the global release. This article looks at something different: a single, documented, real-world run published by Google engineers George Weale, Bo Yang and Andrew Biernat on the Google Developers Blog on 13/10/2026. They pointed Argon at google/adk-python, the open-source Agent Development Kit, and asked it to find and fix cross-file performance bottlenecks.

The headline numbers are modest on purpose. Pre-model session preparation became about 40% faster in long sessions, import google.adk became 21% faster, and a 158-turn tool-calling run dropped from 65.6 seconds to 56.1 seconds. Google itself notes that per-call savings of 28 ms and 78 ms are hard to feel against a single LLM call. The interesting part is the process. Round one, with no repository guidance, produced useful ideas and several mistakes. Round two, with a maintainer rulebook and a persistent goal, ran for 11 hours and produced a change that survived review.

Three conclusions stand out. First, long-horizon agents are only as good as the context you give them about how your repository works. Second, passing the open-source test suite is not the same as being safe to ship: a lazy-import change that passed all 16,892 public tests broke 25 internal Google targets. Third, human review remains the filter that turns an agent's exploration into a mergeable change. If you are choosing a coding agent, our guide to the best AI coding agents sets this in the wider market.

Sourcing note: every figure in this article comes from Google's Developers Blog post, Google's Argon announcement, or Artificial Analysis. All of it is vendor-reported or third-party reported; we have not re-run the experiment.

Google's authors chose performance optimisation deliberately. A bug can often be fixed by reading one function. A slowdown usually cannot. The cost may sit in how a session is copied on every read, in what gets imported before any agent code runs, or in a chain of calls across many modules. To fix it, a model has to trace callers, understand shared references and know which behaviours other code depends on.

The target was large enough to matter: about 205,000 lines across nearly 800 source files, with nearly 17,000 unit tests (16,892 were run in the final round). The goal was strict. ADK should add no noticeable overhead at startup, in long sessions, and in multi-agent and workflow setups, while leaving the public API and the content sent to the model unchanged, and each change needed a regression test.

This is the kind of task the industry means when it talks about long-horizon agents. It is also the kind of task that exposes the gap between a clever diff and a safe one. Our earlier look at the AI coding agents productivity study argued that review time is where much of the claimed gain goes missing. Google's experiment makes that visible in a way few vendor demonstrations do.

The model itself is described in Google's announcement as built for deep reasoning across long workflows, with a 1 million token output limit. We analysed that claim, and the surrounding benchmark table, in our Argon launch review. Here the question is narrower: what happens when you leave it alone overnight?

In the first round Google gave Argon a single paragraph of instructions and no repository-specific guidance. It ran for about two hours. By the seven-minute mark it had written a benchmark script, and it spent roughly 70 minutes reading and measuring before it edited any ADK source. Its diagnosis was sound: it found real bottlenecks in session copying and package imports.

The problems were all about convention and verification rather than raw intelligence:

• A public schema changed. Argon added a hook to ADK's authentication model that subtly altered its public JSON schema, which the brief had told it not to do.
• Edge cases were missed. Its custom copier did not handle mock-event edge cases.
• Verification was shallow. It ran only 216 nearby unit tests out of nearly 17,000.
• The handoff was thin. It left benchmark numbers out of the pull request description.

None of this is surprising to anyone who has onboarded a new engineer. The agent did what a talented newcomer does: it found the real problem, solved it quickly, and did not know the house rules. Parts of round one's code did survive into the final commit, which shows the exploration was valuable even though the first packaging was not.

Round two changed two things, and the comparison above shows how much they mattered.

A repository rulebook in .agents/skills

Maintainers added guidelines in an .agents/skills directory, structured like onboarding documents. Each skill has a short SKILL.md index that points to references/ files loaded on demand, which keeps the context window small. Argon read 12 of these guideline files before touching any source. Two examples the authors give are a rule about keeping new helpers in private underscore-prefixed modules and a check for lazy-loading imports. If you have used skills in other tools, the pattern will be familiar; our explainer on Claude Skills and the piece on Gemini Skills replacing Gems cover the same idea of on-demand instruction files.

/goal mode in Google Antigravity

The second change was /goal mode in Google Antigravity. The goal persists across context compactions, so the agent keeps working until the task is finished rather than losing the thread when its window fills. The prompt also now required a single unmerged pull request against main, with before-and-after numbers in the description. For more on the tool, see our Antigravity 2 plan review.

What the overnight run looked like

The run started at 9:11 PM and finished at 8:19 AM, 11 hours later. Before editing anything, Argon ran a baseline benchmark at the ten-minute mark across four workloads: package startup, a 200-step conversation, a 20-sub-agent handoff app and a 12-node workflow, with 30 runs each. That discipline, measure first, change second, is what separated round two from round one, where the first edit came 70 minutes in without a baseline of that kind.

Near the end, Argon caught a bug in its own multi-agent cache. It then re-ran all 16,892 unit tests, along with type checks and linters, before stopping on its own. In the morning it left one unmerged pull request with before-and-after tables across four workloads. Compare that with round one's 216 tests and missing numbers, and the value of persistent instructions is clear.

Argon's pull request proposed six optimisations across 32 files. The maintainers shipped two and rejected four. The final merged change was 22 files with 17 new test functions, landed on main with the commit note "Argon generated these changes" (commit 1754b3ee in google/adk-python).

Shipped: filter session events before copying

ADK's in-memory session service used to deep-copy the entire stored conversation on every read, then filter it. Listing sessions without their events still copied every event. Argon moved the filtering ahead of the copying and replaced Pydantic's generic deep copy with a faster, cycle-safe copier that keeps shared state dictionaries and test mocks intact. This is the change that drives the headline 40% figure.

Shipped: lazy-load heavy packages

import google.adk loaded live audio and video support, OpenTelemetry and FastAPI/Starlette even for a basic text agent. Argon's first round-two attempt simply removed three top-level flow imports from llm_agent.py. All 16,892 open-source tests passed. But 25 internal Google test targets failed, because they patch those attributes directly. The shipped version uses lazy module accessors, so heavy packages load on first use and the public attributes remain patchable. This is the single best illustration in the post of why green tests are necessary but not sufficient.

Rejected: the multi-agent event cache

This one looked impressive: 17% faster on a synthetic benchmark. But it relied on a weak memory reference that could return stale data across sessions if Python reused a memory address after garbage collection. A rare, silent data-leak risk is a bad trade for a synthetic gain, and reviewers cut it.

Rejected: telemetry gating on a private attribute

Argon proposed a check that read a private attribute on OpenTelemetry's tracer. That could break silently on a minor library upgrade. Reaching into another project's internals is precisely the sort of shortcut maintainers refuse.

Rejected: conversation-history formatting rewrite

A rewrite of how history is formatted before each model call made a core path harder to read without improving end-to-end latency on the holdout benchmark. Complexity without measurable benefit does not ship.

Rejected: workflow replay index

A lookup index for workflow event replays added state-tracking complexity and helped only synthetic replay tests, not everyday runs. Google's authors summarise the whole pattern in one line on their graphic: the agent explores, the maintainer subtracts. That is a sensible division of labour, and it is more honest than most agent marketing.

The measurement design is as important as the numbers. Google's authors wrote a holdout benchmark (bench_turn.py) beforehand that Argon never saw. A single session grows turn by turn against an instant model and instant tools, so what is measured is framework overhead alone. Each turn makes three rounds of four parallel tool calls. Timing is taken for five turns after 0, 50 and 150 earlier turns, and every figure is the median of 6 to 12 runs. Model requests were byte-identical before and after.

Reading the numbers honestly

The authors are candid about limits, and we should be too. The 40% gain applies only to InMemorySessionService, which is used by InMemoryRunner, local evaluations, CI, and default Cloud Run or GKE set-ups without an external database. External stores such as SQLite, Firestore and Redis deserialise from storage rather than deep-copying, so their read times do not change. The import gain does not reduce time to first request, because the deferred modules load on the first turn. That is why the new-process figure is flat; Google's advice is that production servers should send a warm-up request before taking traffic.

So, this is a real but bounded improvement: a measurable cut in framework overhead for one deployment shape, delivered with tests, rather than a transformation of agent latency. Most of the wall-clock time in any real agent is the model itself.

The AI Revolution X video above bundles the ADK story with other claims from Google's Argon announcement. Here is what Google actually says, in its own words, on each.

• Quantum error correction. Argon translated AlphaQubit, DeepMind's machine-learning decoder, into a single optimised hardware kernel, "nearly doubling its inference throughput".
• Quantum arithmetic. For arcsin, a building block of quantum simulation algorithms, Argon's implementation, formally verified in Lean, reportedly cuts spacetime cost by more than 100 times against a published quantum CORDIC baseline.
• Fusion. Working with Professor Matt Landreman, Google found a broader class of counterexamples to Grad's conjecture, a hypothesis dating to 1967 about exact solutions for stellarator magnetic fields, giving researchers benchmarks for simulation codes.
• Robotics. Argon watched a raw video of a person playing cornhole, mapped the environment, worked out the joint movements and wrote the simulation code. Transferred to Apptronik's Apollo humanoid, the robot sank seven consecutive shots in a real-world trial. Google reports 87% on the ERQA embodied reasoning benchmark.

These are all Google claims, and we have not seen independent replication. They are, however, consistent in kind with the ADK run: tasks where a model must hold a large technical problem in mind, verify its own work and produce an artefact, rather than answer a question. For the safety and cyber side of the same release, see our coverage of the global release.

Google's published comparison shows Argon leading on most lines against GPT-6 Astra and Claude Opus 5.5; we reproduced and checked that table in our launch review. Independent evaluator Artificial Analysis tells a more mixed story. Its comparison page, which the AI Revolution X video cites, lists both models as released in September 2026 with the same 1.0 million token context window, and gives these figures:

Two things follow. First, on Artificial Analysis's composite, Opus 5.5 is ahead by five points, which matches the video's claim that Claude still leads in independent tests. Second, Argon is substantially cheaper to run, partly because its list prices are half Opus 5.5's ($2 and $10 per million tokens against $4 and $20) and partly because it uses about half the output tokens per task. For high-volume agent work, cost per completed task may matter more than a five-point index gap. Our Claude Opus 5.5 review and the head-to-head Opus 5.5 vs GPT-6 Astra give the other side of the comparison, and our benchmark roundup explains why single leaderboards mislead.

We deliberately omit the latency figures on the Artificial Analysis page, which are listed as single values not attributed to a model and which look implausible as published.

You do not need Argon to learn from this experiment. Google's authors draw five lessons, and each is tool-agnostic. We have added how we would apply them.

1. Encode maintainer knowledge in the repository. The jump from round one to round two came from guidelines files and explicit pull request requirements. Write down your private-module rule, your test commands and your definition of a done change. Keep an index file short and load detail on demand.
2. Make the agent measure first. Require a baseline benchmark before any edit, and require before-and-after numbers in the description. This forces honest comparison and gives the reviewer something to check.
3. Hold out a benchmark the agent never sees. The authors' holdout benchmark exposed changes that looked good on synthetic tests but did not move end-to-end latency. If the agent writes the test and the fix, you are marking its homework with its own answers.
4. Do not trust green tests alone. The lazy-import change passed every open-source test and still broke 25 internal targets. Ask what patches, mocks and downstream consumers the suite does not cover.
5. Keep the human as the subtractor. Reject weak references, private library internals and synthetic-only wins. Four of six proposals failing review is not a bug in the process; it is the process.

Other agent frameworks use similar mechanisms. Our explainer on Hermes Agent covers a skills-based open-source approach, and the Claude Code material in our Claude Code tool review shows the same pattern with project instruction files.

According to Google's announcement, Argon is globally available through the API in Google AI Studio and the Gemini platform for developers and enterprises (model ID gemini-4-argon). Google AI Ultra subscribers get it in Google Antigravity, and Ultra and Pro subscribers get it in the Gemini app and AI Mode in Search.

Cached input is discounted by 95%. Pound figures are our approximate conversions; Google quotes dollars. If you are planning an overnight agent run, remember that long runs consume many output tokens, so model the cost on tokens per task, not on the headline rate.

• One repository, one vendor. This is Google engineers testing Google's model on Google's own project, with a rulebook they wrote. Results on your codebase will differ.
• Narrow gains. The speed-up applies to in-memory sessions and does not change time to first request in a new process.
• Human review did the heavy lifting. Two of six proposals shipped. Without maintainers, the rejected four would have introduced stale-data and fragility risks.
• Tests under-cover reality. Even 16,892 passing tests missed 25 internal failures in the lazy-import change.
• Independent scores are lower. Artificial Analysis ranks Opus 5.5 ahead on its Intelligence Index, so treat Google's table as a claim, not a verdict.
• Non-code claims are unreplicated. The quantum, fusion and robotics results are Google's own statements.

Gemini 4 Argon's overnight ADK run is the most instructive agent case study of the month, precisely because it is not a triumph. An agent worked unattended for 11 hours, produced six ideas, and had two of them accepted. The improvement was real, measurable and bounded. The failures were useful: a changed public schema, an under-tested copier, a lazy import that broke internal tests, and a cache that could leak stale data.

The practical lesson is that the quality of an agent's output tracks the quality of the context and review process around it. Write your rules down, make the agent measure, hold out your own benchmark, and keep a human whose job is to say no. If you do that, a model like Argon, or a rival from our best AI models list, becomes a force multiplier. If you do not, you will review a lot of clever diffs that should never have been written.