Baking with Gemini 4 Argon, Early Access: 43 Sessions, 24 Builds

As part of Google’s Early Access Program (EAP), I got early access to Gemini 4 Argon across the API, Gemini Chat, agy CLI, and my daily workflows. It consumed my sleep over the past two weeks.

43 sessions. 131.0 active hours (157.6 working session hours) and ~41,800 agent steps, almost all of it logged over weekends and late nights after work. I threw 24 builds (14 greenfield + 10 enhanced/OSS) at it across Rust, Swift, WebGPU, WASM, Blender Python, Cloudflare Workers, and Node SQLite. Along the way, we also shipped upstream PRs to browser-use (#5992) and mcp-use (#2763).

After two weeks of late-night and weekend marathons, I wanted to see what actually happened across all those sessions. So I pointed Argon at its own .jsonl logs in ~/.gemini/antigravity-cli/brain using agent-diary to pull out the exact step-to-step timestamps, retry loops, and root-cause fixes:

Session Telemetry Metric	Measured Value	How It Was Computed from .jsonl Logs
Strict Active Build Time	131.0 hrs	Sum of step-to-step intervals where gaps between steps were <= 15 min (mostly late nights + weekends)
Working Session Time	157.6 hrs	Sum of intervals with a 30-min idle cap (includes local compiles, benchmark runs, and reading diffs)
Total Agent Steps	41,778 steps	Across 43 project sessions (24 shipped builds: 14 greenfield + 10 enhanced/OSS)
Longest Single Marathons	10.0 hrs / 6.2 hrs	Vāgdhenu Studio (5,310 steps, 10.0 hrs), WebML-Kit (1,827 steps, 6.2 hrs), XKCD-Bench (3.8 hrs)

How we generated images from what we learned

If you ask an image diffusion model to render a diagram with 32 technical findings across 24 projects, you get unreadable text slop.

Instead, we wrote a deterministic SVG generator (generate_blueprint.js) that parses the .jsonl logs, builds monochrome SVG blueprints (Instrument Serif + Geist Mono, 1.2px strokes), and renders 2x Retina PNGs (3936x2080 and 3936x2440) through headless Chromium.

The first version had everything crammed into one static canvas. Way too noisy. We turned the portfolio overview above into an interactive expandable blueprint starting from the central Gemini 4 Argon node, dropped the token vanity metrics, and broke the 24-project findings into per-section cards for The Good, The Ok, and The Fun below.

Where we did use image models and vision pipelines across the projects, three things stood out:

1. Ruins bias on 1520 CE Hampi: I wanted a 3D reconstruction of Hampi during Krishnadevaraya’s reign (hampi). First-pass image prompts kept giving me broken roofs and weathered stone. Almost every photo of Hampi online is post-1565 ruins, so the model’s visual prior defaults to ruins. We had to explicitly prompt for intact painted lime-plaster gopurams and active bazaars, then bake tileable granite PBR textures (texture_granite_carving.jpg) because glTF drops Blender’s procedural shader nodes on export.
2. Copyright-free food photos: For a South Indian recipe app (Mangalore Buns, Congress Kadalekai, Bendekayi Gojju), scraped photos meant copyright headaches. We regenerated every dish from scratch with Gemini image generation on dark slate.
3. Exact 300 DPI print geometry: Resizing NASA OPAL’s Jupiter image to 22cm x 10cm for a science board, plus 2x2 inch transparent cutouts for Europa and Io and 2.5"x3.5" contact sheets at 300 DPI (750x1050 px). Older models always botched the DPI-to-pixel math or aspect-ratio padding. Argon nailed the geometry on Pass 1.

Science-backed builds & empirical numbers

Most AI demos stop at a wrapper around an API call. For these builds, we grounded the core logic in published papers, mathematical invariants, and held-out benchmarks:

1. Flow-Matching ODE Calibration in Vāgdhenu (Live Studio · HF Weights)

Vāgdhenu is a single-speaker Sanskrit chant (pārāyaṇa) TTS trained on 16,017 verses of the Śrīmad Bhāgavatam (MOS ~4.6). Running its Conditional Flow Matching (CFM) DiT + Vocos pipeline inside the browser via WebGPU originally took 36.6s per verse and required 1.8 GB of weights.

Over a 5,310-step session (including a 1,907-step overnight /goal loop), Argon ran grid searches over quantization schemes and ODE solvers:

ODE Schedule:   t_k = 1 - cos(π * k / (2 * N))   for k = 0..N  (N = 9 steps)
Cross-Attn:     O(T_ref * T_gen)  -> trimmed T_ref from 879 frames (10.2s) to 340 frames (4.0s)

Configuration	Weight Size	ODE Steps (NFE)	STFT_cos Parity	Flow Trajectory r	WebGPU TTFA
Baseline FP32 (Sequential)	1,810 MB	32 (Uniform Euler)	1.000	1.00	36.6 s
Naive INT8 Dynamic (DiT + Text)	290 MB	16 (Uniform Euler)	0.612	0.22 (Collapsed)	8.4 s
Hybrid (Q4 Text + FP16 DiT + Worker)	367 MB	9 (Cosine Schedule)	0.954	0.97	5.8 s

Quantizing the DiT velocity field to INT8 destroyed the ODE trajectory (r = 0.22). Keeping the DiT in FP16, quantizing only the text encoder to Q4, moving Vocos to a Web Worker, and overlapping Part 1 audio playback with Part 2 GPU synthesis cut weights by 80% and brought time-to-first-audio down to 5.8s.

2. QMR-DT Bayesian Networks & Phrank IC in DDx (GitHub · npm)

DDx classifies patient symptoms and pertinent negatives into 49 ICD-10 differential diagnoses. Instead of trusting raw LLM probabilities, it combines Shwe et al. (1991) Quick Medical Reference Decision-Theoretic (QMR-DT) Noisy-OR networks with Jagadeesh et al. (2019) Phrank Information Content (IC(s) = -log2 P(s)), compiled from N = 8,000 cases in the NeurIPS DDXPlus dataset (Fansi Tchango et al., 2022) and paired with TypeSafe System One (jev-1.13.0) or in-browser WebAssembly (Qwen3.5-4B via @wllama/wllama).

To pick the next best bedside question, it maximizes expected Shannon entropy reduction across candidate diseases $D$:

ΔH(D | S) = H(D) - Σ P(S = s) * H(D | S = s)   for s ∈ {present, absent}

Evaluated on N = 60 held-out DDXPlus clinical vignettes across full (100%), partial (50%), and sparse (35%) symptom histories:

Method	Top-1 (100% Hx)	Top-1 (50% Hx)	Top-1 (35% Sparse)	Top-3 (35% Sparse)	Mean Brier	p50 Latency
DDx Full (TypeSafe Jev + QMR-DT)	100.0%	98.3%	93.3%	98.3%	0.0021	126.1 ms
QMR-DT + Phrank IC (Deterministic)	100.0%	98.3%	93.3%	98.3%	0.0021	< 0.1 ms
QMR-DT Uniform Noisy-OR	100.0%	96.7%	91.7%	98.3%	0.0025	< 0.1 ms
Cosine TF-IDF (IC Vector)	96.7%	90.0%	83.3%	96.7%	0.0176	< 0.1 ms
Unweighted Jaccard Baseline	91.7%	83.3%	75.0%	95.0%	0.0185	< 0.1 ms

3. YIN Pitch Tracking & 34,776 Janya Scales in Swaraga (GitHub)

Swaraga identifies Hindustani and Carnatic ragas from live vocal audio. It runs de Cheveigné & Kawahara (2002) YIN $F_0$ autocorrelation on 16 kHz mono PCM, locks tonic Sa, maps pitch trajectories into 12 swarasthana cent histograms ($1200 \log_2(f / f_{\text{Sa}})$), and extracts Pakad phrase motifs.

It covers 962 named ragas, generates all 72 parent Melakarta scales from the Katapayadi sankhya chakra formula, and resolves all $72 \times 483 = 34,776$ theoretical linear janya scales (Audava, Shadava, Sampurna) to their parent Melakartas, ranking candidates by the hierarchical beam score:

Score(Raga) = sqrt( P(Thaat_Family) * P(Raga | Acoustic_Swaras, Pakad_Motifs) )

4. Multi-Agent Git Coordination & AST Symbol Locks in GitTub (GitHub)

When we ran 5 to 7 parallel subagents on a repo, they kept stepping on each other’s files or drifting on function signatures. Inspired by Cloudflare’s Next Git Platform on Cloudflare, we built GitTub on Cloudflare Workers and Artifacts to coordinate concurrent coding agents:

// 1. Agent authenticates -> auto-provisions an isolated zero-copy task-<uuid> fork
const { session } = await fetch("https://gittub.hemanthhm.workers.dev/api/auth/login", {
  method: "POST",
  body: JSON.stringify({ actorType: "agent", identity: "agent:gemini-4-argon" })
}).then(r => r.json());

// 2. Claim an AST symbol lock before editing so peer agents see active boundaries
await fetch("https://gittub.hemanthhm.workers.dev/api/intents", {
  method: "POST",
  body: JSON.stringify({
    repo: "core/runtime",
    symbols: ["src/router.ts#dispatchTool", "src/schema.ts#ToolContract"],
    intent: "Refactor tool router signature"
  })
});

On login, GitTub asks whether you are a Human or an Agent and switches the entire interface: humans get a visual AST lock timeline and merge arena, while agents get machine-readable JSON contracts, causal commit notes (refs/notes/agent-trace), and pre-commit symbol collision gates.

5. Multimodal Humor & Perceptual Ink Hashing in XKCD-Bench

Built on olivierdehaene/xkcd (2,630 comics) and dchichkov/explainxkcd, XKCD-Bench grades vision-language models across a 4-pillar rubric (30% Humor Subversion, 30% Technical Domain, 20% Visual Panel Grounding, 20% Alt-Text Synthesis) and tracks Expected Calibration Error (ECE). For reverse comic search, it combines <5 ms 64-bit perceptual dHash + aHash + 3x3 spatial ink-density fingerprinting with google/embeddinggemma-2 vector retrieval.

The Good

Long /goal runs hold up. Whether running 5,310 steps on Vāgdhenu, 1,859 steps on hampi, or 1,234 steps on GitTub, Argon keeps iterating until the metric passes in headless Chrome.

4,200 lines in one pass. For hampi, it wrote a 4,200-line procedural Blender Python script (generate_hampi_1520.py) in a single shot. No lost variable names. No // ... rest of code bailouts.

Natural tool and skill routing. It wired episod x-episod-session-id KVCache affinity into browser-use PR #5992 (117k stars) so multi-step browser agents stop re-prefilling 40k DOM tokens on every turn. And it wired tool-prune into mcp-use PR #2763 (10.7k stars) for 0.4 ms BM25 pre-flight schema pruning, verified with benchstat.

Indic linguistics out of the box. Across Shanti Mantra (GitHub · HF Dataset), suktam, sanskrit-tokenizer, and dhaturupa, Argon handled Paninian sandhi splits and Madhvacharya’s Tattvavada commentary across all 108 Upanishads. It even knew to route Sanskrit TTS through Kannada script (kn-IN) so Hindi schwa-deletion wouldn’t drop the final short ‘a’ in words like rāma.

The Ok

Coding before discussing. While working on SmartCursor.app, I typed "hmm, discuss". Argon immediately wrote 400 lines of Swift for a Spotlight sidecar. When I say discuss, I want options before code.

Over-engineering Pass 1. For SmartCursor.app, the first pass was a heavy standalone macOS window instead of a tiny inline pill next to the cursor. It also hid the hotkeys (⌥Space, ⌘Space) in terminal logs instead of showing them in the UI.

Blind 3D camera placement. The Three.js and Blender code in Attention 3D and hampi runs without syntax errors on the first try, but the camera might spawn right behind a stone pillar. Until the agent opens Playwright and inspects a rendered frame, it is flying blind on 3D geometry.

Subagent contract drift. Before we built GitTub, running 5 to 7 subagents in parallel (one building a .glb asset in Blender while another wrote the Three.js loader) meant they occasionally drifted on mesh node names unless locked to a shared schema.

Fallback mocks mixed with real telemetry. While building Hearth (a LAN parental monitor), Pass 1 blended hardcoded demo device cards with live ARP reads. My prompt: "lol, how true is that data?" Once called out, Argon ripped out the mocks, wrote a Rust UDP DNS gateway, pulled .ha hardware radio counters from my AT&T BGW320 router, and parsed Chrome Sync LevelDB (.ldb) SSTables with Snappy.

Premature "Render Complete" before checking frames. In Caption-It Studio (GitHub, powered by Cactus Whistle 16.9 MB WASM STT), the UI said "Render Complete" even though broken CDN font URLs caused every burned caption to silently drop. Browser MediaRecorder WebM files also carry a bizarre 1000-tbr variable container timebase that made ffmpeg.wasm run 33x slower until we forced -r 30 and scaled portrait video (484x1080) by min(W,H).

WebAudio synthesis on Pass 1. On Shanti Mantra, the first pass synthesized WebAudio formants that sounded like a 1990s dial-up modem ("nah, audio sucks"). We swapped it for millisecond-aligned human vocal audio (Madhur and Swara voices). Similarly, on Eloquent Web (GitHub), we had to fix five mobile WebAudio buffer bottlenecks on a Pixel 10 Pro XL and lazy-warm the 355 MB worker using webml-kit.

The Fun

Rick & Morty x Argon. I asked if it could make a video with just the model and no CLI. After three turns of debating that, we used HyperFrames, GSAP, and Pocket TTS (with my cloned voice) to render a 48-second animated episode about our own sessions.

Point and talk to the DOM (voxmark). Using WebMCP (navigator.modelContext), you click any element in Chrome, say what you want changed out loud, and the background agent patches the source file live.

Trading and music from the terminal. We baked agenthood (PyPI) to map 53 MCP tools to Robinhood’s APIs, plus spotify-mod and voice-mod to stream Spotify album art and on-device Moonshine voice dictation directly inside the terminal status bar.

Mining my own 2 AM grumpiness (agent-diary). Parsing our .jsonl logs showed that my grumpiest prompts ("36.6s ha??", "nah, audio sucks", "looks very shitty") almost always triggered the best fixes in the next 10 steps. Argon doesn’t get defensive. Push back hard and it digs into the raw bytes.

Four rules I added to my agent setup

We turned the mistakes from these 43 sessions into four Stoic rules (Ta Eis Heauton), generated a monochromatic schematic with Nano Banana to keep them top of mind, and dropped them straight into our agent config:

1. Katalepsis (Truth): Never mix mock fallback data with live system telemetry. Fail loud on OS permission boundaries instead of faking a green dashboard.
2. Metron (Measure): Zero "Render Complete" declarations without extracting a mid-video PNG frame and checking STFT_cos audio parity.
3. Eukairia (Timing): Keep streaming TTFA under 6.0s, trim conditioning prompts to 4.0s, isolate CPU vocoders in Web Workers, and overlap GPU synthesis with playback.
4. Apallage (Restraint): Ship uncluttered zero-scroll layouts and inline cursor pills on Pass 1. When asked to "discuss", present trade-offs before writing code.

Models don’t struggle with syntax anymore. They struggle with silent fallbacks, container quirks, and assuming exit code 0 means the feature works.

Keep the feedback blunt, verify the output against real math and a real browser, and you can ship a wild amount of code in two weeks.

AI engineer your projects, don’t just Vibe Code. Plan it, use your taste and skills.