---
title: "Baking with Gemini 4 Argon, Early Access: 43 Sessions, 24 Builds"
description: "131 active hours in Google Early Access with Gemini 4 Argon across 43 sessions, 41,778 steps, and 24 builds: Good, Ok, Fun."
url: "https://h3manth.com/scribe/baking-with-gemini-argon/"
canonical_url: "https://h3manth.com/scribe/baking-with-gemini-argon/"
markdown_url: "https://h3manth.com/scribe/blog/baking-with-gemini-argon.md"
publishDate: "2026-10-13T18:00:00.000Z"
author: "Hemanth HM"
category: "ai"
tags: ["ai","agents","gemini","argon","google-eap","antigravity","webgpu","gittub","science","benchmarks"]
word_count: 2432
reading_time_minutes: 13
x_markdown_tokens: 4609
content_signal: "ai-train=yes, search=yes, ai-input=yes"
---

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

> 131 active hours in Google Early Access with Gemini 4 Argon across 43 sessions, 41,778 steps, and 24 builds: Good, Ok, Fun.

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)](https://github.com/browser-use/browser-use/pull/5992) and [mcp-use (#2763)](https://github.com/mcp-use/mcp-use/pull/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](https://github.com/hemanth/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](https://h3manth.com/ai/sanskrit-tts/) (`5,310` steps, `10.0 hrs`), [WebML-Kit](https://github.com/hemanth/webml-kit) (`1,827` steps, `6.2 hrs`), [XKCD-Bench](https://h3manth.com/ai/xkcd-bench/) (`3.8 hrs`) |

![Everything Baked Afresh & Enhanced with Gemini 4 Argon](../../assets/blog/argon-projects-blueprint.png)

## 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.

![Telemetry-to-Blueprint Compiler Pipeline](../../assets/blog/argon-pipeline-flow.png)

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.

![1520 CE Virupaksha Bazaar Reconstruction](../../assets/blog/hampi-1520-argon.jpg)

## 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](https://prathosh.in/vagdhenu/) ([Live Studio](https://h3manth.com/ai/sanskrit-tts/) · [HF Weights](https://huggingface.co/prathoshap/vagdhenu))

[Vāgdhenu](https://github.com/prathoshap/vagdhenu) 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](https://h3manth.com/ai/ddx/) ([GitHub](https://github.com/hemanth/ddx) · [npm](https://www.npmjs.com/package/ddx))

[DDx](https://h3manth.com/ai/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](https://h3manth.com/fun/swaraga/) ([GitHub](https://github.com/hemanth/swaraga))

[Swaraga](https://h3manth.com/fun/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](https://gittub.hemanthhm.workers.dev) ([GitHub](https://github.com/hemanth/gittub))

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](https://blog.cloudflare.com/next-git-platform-on-cloudflare/), we built [GitTub](https://gittub.hemanthhm.workers.dev) on Cloudflare Workers and Artifacts to coordinate concurrent coding agents:

```js
// 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](https://h3manth.com/ai/xkcd-bench/)

Built on [`olivierdehaene/xkcd`](https://huggingface.co/datasets/olivierdehaene/xkcd) (2,630 comics) and [`dchichkov/explainxkcd`](https://huggingface.co/datasets/dchichkov/explainxkcd), [XKCD-Bench](https://h3manth.com/ai/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

![The Good: First-Pass Wins & Science Breakthroughs](../../assets/blog/argon-good-card.png)

**Long `/goal` runs hold up.** Whether running 5,310 steps on [Vāgdhenu](https://h3manth.com/ai/sanskrit-tts/), 1,859 steps on `hampi`, or 1,234 steps on [GitTub](https://gittub.hemanthhm.workers.dev), 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](https://github.com/hemanth/episod) `x-episod-session-id` KVCache affinity into [browser-use PR #5992](https://github.com/browser-use/browser-use/pull/5992) (117k stars) so multi-step browser agents stop re-prefilling 40k DOM tokens on every turn. And it wired [tool-prune](https://github.com/hemanth/tool-prune) into [mcp-use PR #2763](https://github.com/mcp-use/mcp-use/pull/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](https://h3manth.com/fun/shanti/) ([GitHub](https://github.com/hemanth/shanti-mantra) · [HF Dataset](https://huggingface.co/datasets/hemanth/shanti-mantras)), `suktam`, [sanskrit-tokenizer](https://github.com/hemanth/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

![The Ok: Pass-1 Gotchas & Multi-Turn Refinements](../../assets/blog/argon-ok-card.png)

**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](https://h3manth.com/ai/attention/) 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](https://gittub.hemanthhm.workers.dev), 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](https://h3manth.com/ai/caption-it/) ([GitHub](https://github.com/hemanth/caption-it), powered by [Cactus Whistle](https://cactuscompute.com/blog/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](https://h3manth.com/fun/shanti/), 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](https://h3manth.com/ai/eloquent/) ([GitHub](https://github.com/hemanth/eloquent-web)), 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](https://github.com/hemanth/webml-kit).

## The Fun

![The Fun: Creative Builds, Hardware Hacks & 2 AM Episteme](../../assets/blog/argon-fun-card.png)

**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](https://github.com/hemanth/voxmark)).** Using [WebMCP](https://github.com/webmachinelearning/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](https://github.com/hemanth/agenthood) ([PyPI](https://pypi.org/project/agenthood/)) 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](https://github.com/hemanth/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:

![Four Stoic Engineering Laws (Ta Eis Heauton)](../../assets/blog/stoic-agent-rules.jpg)

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.**