Google reports an 11-hour Argon run in Antigravity /goal on ADK; human review merged only 2 of 6 proposals. Repository rules, benchmarks, and review matter. This is not a general performance guarantee.
Suitable tasks: Cross-file performance investigation in an existing large Python codebase, session-history copy optimization, lazy loading for heavy packages, benchmark development, and filling test gaps; especially Agent tasks that need long runtimes and human review.
Unsuitable tasks: The case does not guarantee the same gains for arbitrary repositories. It cannot replace maintainer review or justify extrapolating synthetic benchmark gains to production traffic.
Model version: Gemini 4 Argon; the original does not provide a more specific API version or reasoning tier.
Client, Agent, or API: Google Antigravity's /goal mode; the case provides no Tabbit, API request schema, or other client configuration.
Recommended reasoning tier and parameters: Not specified. The original does not disclose temperature, token limits, tool configuration, or request parameters.
The following two passages are the work goals publicly disclosed in the original and are preserved as written. They are case-study evidence, not prompts that can be assumed to reproduce the same result in another codebase without adjustment.
Make ADK add no noticeable overhead to any agent:\ at startup, in long sessions, in multi-agent and\ workflow setups. Ke… This is a necessary excerpt; read the original source for full context.
/goal prompt/goal Make ADK add no noticeable overhead to any agent:\ at startup, in long sessions, in multi-agent and workflow setup… This is a necessary excerpt; read the original source for full context.
The second round also placed the maintainer rules in the repository's .agents/skills directory. Each skill used SKILL.md as an index and pointed to files in references/ as needed, avoiding putting all rules into the context on every round. The original does not provide a complete directory applicable to other projects.
Select an existing large codebase and a measurable goal. The case used Google ADK: approximately 205,000 lines of Python, nearly 800 source files, and nearly 17,000 unit tests.
In the first round, provide no custom repository rules—only the goal prompt. The run lasted about 2 hours: at 7 minutes it wrote a benchmark script; it then spent about 70 minutes measuring and reading code before editing ADK source code.
Record the first round's failure boundaries: a custom hook added to an authenticated model changed the public JSON schema; a custom copier missed a mock-event boundary; only 216 nearby tests were run; and the pull request did not include benchmark numbers.
Put the maintainer conventions in .agents/skills, then enable /goal mode in Google Antigravity so the goal persisted across context compression. The second round started at 9:11 p.m. and ran unattended for 11 hours.
Have the model read 12 rule files and run baseline tests for four workload classes, 30 runs per class: package startup, a 200-step conversation, a test application in which 20 child Agents passed tasks among one another, and a 12-node workflow.
Ask the model to propose optimizations and generate an unmerged pull request with before-and-after numbers. Maintainers then checked cross-module references, mock targets, shared references, the public API, and regression tests one by one.
Keep the two changes that cleanly resolved the core bottlenecks and reject the other four. Submit the final 22-file change with 17 new test functions to the main branch. The original describes the commit as “Argon generated these changes”.
Filter in-memory session history before copying: Previously, every read deep-copied the full conversation and then filtered the events needed by the caller. Argon changed this to filter first and copy second, and replaced Pydantic's generic deep-copy path with a fast copier that can handle circular references, while preserving the shared state dictionary and test mocks.
Load heavy packages only when needed: import google.adk previously loaded real-time audio/video, OpenTelemetry, FastAPI, and Starlette even when an Agent handled only text. The final change used a lazy module accessor so heavy packages loaded only on first use, while keeping public attributes patchable in tests.
For the second optimization, deleting three internal flow imports from llm_agent.py made 16,892 open-source tests pass, but 25 Google-internal test targets failed because they patched those attributes. The case kept the patchable public attributes and merged the change only afterward.
A multi-Agent event cache was 17% faster on a synthetic benchmark but used fragile memory references; after Python garbage collection, a reused address could return stale data from another session.
The telemetry check read private attributes of the OpenTelemetry tracer implementation, which could silently break after a minor-version upgrade.
Rewriting conversation-history formatting before every model call made the core path harder to read without improving end-to-end latency on the independent holdout benchmark.
The workflow event-replay lookup index increased state-tracking complexity and helped only the synthetic replay test, not everyday Agent runs.
The original says the team wrote an independent holdout benchmark, bench_turn.py, before the two runs—one Argon had not seen. It used an instantaneous model and instantaneous tools so that timing primarily reflected ADK framework overhead. Each turn executed three rounds, with four parallel tool calls per round, measuring five turns after 0, 50, and 150 existing turns. Each number was the median of 6–12 runs, and each turn received byte-for-byte identical requests before and after the change.
| Result reported by the original | Scope and limitations |
|---|---|
| About 40% lower memory-preparation overhead before model requests in long sessions | Applies mainly to InMemorySessionService; a single LLM call saves only a few tens of milliseconds, and the difference becomes noticeable only after as many as 158 internal turns accumulate. |
21% faster cold-start package import for import google.adk | Time from a new process to the first model request was essentially unchanged: 3.07 seconds to 3.09 seconds, because the lazy modules loaded on the first turn. |
| The 158-turn run fell from 65.6 seconds to 56.1 seconds | The original attributes this to nearly 10 seconds less pure framework overhead; read time from external databases, SQLite, Gemini platform, Firestore, or Redis session stores was outside the scope of this change. |
The original also says the optimized import helps CLI, development, and testing discovery. Production servers should send a warm-up request before receiving real traffic so that the first user request does not bear the one-time import cost.
This is Google Cloud's account of its own Agent run; this project did not independently reproduce the code changes, benchmarks, or gains.
The results depend on the ADK codebase, maintainer rules, /goal mode, test suite, and specific benchmark. Do not treat 40% or 21% as fixed improvements for Gemini 4 Argon in other projects.
Only 2 of the 6 solutions proposed by the model passed human code review. The other 4 were rejected because of synthetic gains, private APIs, fragile state, or maintainability problems. Agent exploration cannot replace maintainer trade-offs.
The first round already exposed public-schema changes, missed mock boundaries, insufficient test coverage, and missing PR evidence. A longer second run does not eliminate the need for human acceptance.
The original does not disclose the Antigravity account, region, quota, pricing, reasoning tier, complete tool permissions, or API authentication requirements. “Accessible” does not mean available to every account.
To reproduce this workflow, pin the codebase commit, Python and dependency versions, repository rules, test suite, model entry point, Agent client, /goal settings, and runtime duration. Save the original prompts, complete intermediate logs, full diff, test results, benchmark script, and before-and-after numbers. Use a holdout benchmark the model has not seen, and separately validate the public API, mocks, cross-session data consistency, first-request import cost, and long-session overhead. A maintainer familiar with the codebase should make the final decision about which changes can be merged; do not treat this vendor-reported case study as a general performance commitment.
Gemini 4 Argon