Optimizing a 200,000-line Python codebase overnight with Gemini 4 Argon

An agentic overnight drive to optimize the Google Agent Development Kit (ADK) — a 200,000-line Python codebase — with Gemini 4 Argon. The most valuable part of the story is the division of labor: the agent explores, the maintainer subtracts.

The problem

import google.adk pulled in modules for live audio/video streaming, OpenTelemetry tracing, and web servers (FastAPI, Starlette) — even for a basic text agent. Rewriting top-level imports breaks downstream tests that mock attributes directly on modules.

When Argon's round-two PR removed three internal flow imports from llm_agent.py, all 16,892 open-source tests passed — yet 25 internal Google test targets failed because they patched those exact attributes. The shipped fix: lazy module accessors so heavy packages load only on first use while every public attribute stays patchable where tests expect it.

Six proposals, two shipped

Argon proposed six optimizations. Two shipped; four were cut in code review — and the rejects are the instructive part:

Shipped:

• Session-copy optimization (cut real overhead cleanly)
• Lazy imports (above)

Rejected, and why:

1. A multi-agent event cache sped up a synthetic benchmark by 17% — but relied on a weak memory reference that could return stale data across sessions if Python reused a memory address after GC.
2. A telemetry check read a private attribute on OpenTelemetry's tracer implementation — could break silently on a minor library upgrade.
3. A rewrite of conversation-history formatting made a core code path harder to read without moving end-to-end latency on the independent holdout benchmark.
4. A lookup index for workflow event replays added state-tracking complexity that only helped synthetic replay tests, not everyday agent runs.

The final change: a 22-file change backed by 17 new test functions, landed with the commit note "Argon generated these changes."

What "158 turns" means

The commit's turn count is explained precisely: a "turn" in ADK is the cycle from prompt to final answer — across a full agent session with tool calls, sub-agents, and retries, a single user interaction can span many model turns. 158 turns is the measured optimization-driven count for this workload, which is why raw "turns" without this definition mislead.

Bottom line

This is the pattern agentic refactoring should follow everywhere: let the model explore and propose broadly, keep a rigorous human review with a real test suite and a holdout benchmark, and reject clever-but-fragile changes by measuring what they actually move. The agent found creative solutions humans wouldn't have — and the review process is exactly what made them safe to ship.