---
title: "Baking with Gemini 4 Carbon, Early Access: 490 Sessions, 24 Builds"
description: "127.9 hours in Google Early Access with Gemini 4 Carbon across 490 sessions, 154,277 steps, and 24 builds: Good, Ok, Fun."
url: "https://h3manth.com/scribe/baking-with-gemini-carbon/"
canonical_url: "https://h3manth.com/scribe/baking-with-gemini-carbon/"
markdown_url: "https://h3manth.com/scribe/blog/baking-with-gemini-carbon.md"
publishDate: "2026-11-10T06:00:00.000Z"
author: "Hemanth HM"
category: "ai"
tags: ["ai","agents","gemini","carbon","google-eap","antigravity","onnx","webgpu","wasm","benchmarks"]
word_count: 4313
reading_time_minutes: 22
x_markdown_tokens: 8397
content_signal: "ai-train=yes, search=yes, ai-input=yes"
---

# Baking with Gemini 4 Carbon, Early Access: 490 Sessions, 24 Builds

> 127.9 hours in Google Early Access with Gemini 4 Carbon across 490 sessions, 154,277 steps, and 24 builds: Good, Ok, Fun.

![Baking with Gemini 4 Carbon (C-6): 490 Sessions, 154,277 Steps, 24 Builds](../../assets/blog/baking-with-gemini-carbon-og.jpg)

Right after shipping 24 projects on [Gemini 4 Argon](/scribe/baking-with-gemini-argon/), I got early access to **Gemini 4 Carbon** through Google's Early Access Program (EAP) across the API, Gemini Chat, and `agy` CLI. Over two weeks of late nights and weekends, how I build software shifted from single-agent marathons to coordinated swarms.

With Argon, I mostly drove single long `/goal` loops (`43` sessions, `41,778` steps). With Carbon, `17` primary sessions fanned out through `/teamwork` into **473 parallel subagent workers** (`490` total conversations and **154,277 agent steps**, `3.7x` Argon's step volume in the same two-week window). Together we trained **48 neural TTS voices** and **12 streaming ASR heads** on budget-capped GCP L4 GPUs (`<$112` total), hit **#1 Overall** on both the live [AIR-Bench 24.05 Long-Doc leaderboard](https://huggingface.co/spaces/AIR-Bench/leaderboard) and [XKCD-Bench](https://h3manth.com/ai/xkcd-bench/) (`87.2%`), published **60+ open weights and datasets** to Hugging Face, and uploaded an upstream Chromium DevTools CL ([`#8779313`](https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/8779313)).

None of it ran on autopilot. Those `127.9` wall-clock hours were active engineering after work and on weekends: **589 steering turns** switching between concise prompt nudges, sharp critique, and architectural mentoring, backed by **35+ custom `SKILL.md` playbooks** distilled from 19 years of web, ML, and TC39 work. Carbon brought serious implementation speed; my job was supplying the phonetic ear at 2 AM, the linear-algebra workarounds when browser runtimes hit walls, and a physical phone on my desk whenever desktop tabs hid real silicon limits.

Just like last time, I pointed [agent-diary](https://github.com/hemanth/agent-diary) at `~/.gemini/antigravity-cli/brain/*/.system_generated/logs/transcript.jsonl` to measure exact step-to-step intervals without double-counting overlapping subagents:

| Session Telemetry Metric | Measured Value | How It Was Computed from `.jsonl` Logs |
| :--- | :--- | :--- |
| **Strict Wall-Clock Active Time** | **`127.9 hrs`** | Union of overlapping `<= 15 min` step-to-step intervals across all sessions (never double-counts parallel workers) |
| **Working Wall-Clock Time** | **`146.6 hrs`** | Union of overlapping intervals with a `30-min` idle cap (includes GCP compiles, phone runs, and diff reviews) |
| **Parallel Swarm Compute Time** | **`414.1 hrs`** | Sum of strict active intervals across concurrent `/teamwork` workers (`454.5 hrs` at `30-min` cap; `3.2x` wall compression) |
| **Steering & Custom Skills** | **`589 turns` · `35+ skills`** | Concise prompt nudges, phonetic & code critiques, systems mentoring & custom `SKILL.md` playbooks |
| **Total Agent Steps** | **`154,277 steps`** | `34,930` parent steps (`17` marathons) + `119,347` subagent steps (`473` swarm workers) across `24` builds |
| **Largest Swarm Marathons** | **`71.9 hrs` / `43.8 hrs`** | [Ninada](https://hemanth.github.io/ninada/) (`14,949` steps + `211` primary workers), [Swanada](https://hemanth.github.io/swanada/) (`5,711` steps + `189` workers), [Nullspan](https://hemanth.github.io/nullspan/) (`4,695` steps, `16.6 hrs`) |

![Everything Baked Afresh and Enhanced with Gemini 4 Carbon](../../assets/blog/carbon-projects-blueprint.png)

## From single-agent `/goal` loops to `/teamwork` swarms & physical silicon

When you train speech models across 12 scripts (`sa`, `en`, `hi`, `kn`, `mr`, `bn`, `ta`, `te`, `ml`, `gu`, `pa`, `or`) or run retrieval ablations across 12 reasoning domains, sequential loops stall out. One bug in Gujarati Unicode normalization blocks Tamil, Telugu, and Kannada behind it.

With Carbon, we settled into a four-stage pipeline pre-loaded with custom `SKILL.md` specs (enforcing zero-dependency module style, monochrome Dieter Rams / Light Paper UIs without purple gradients, `B = 1,000` bootstrap benchmarks, and `Accept: text/markdown` agent negotiation):
1. `/teamwork` fans out isolated per-language or per-benchmark subagents.
2. Heavy PyTorch training and Chromium `autoninja` builds run on spot GCP NVIDIA L4 instances so laptop RAM stays untouched.
3. Zero-dependency binary ONNX protobuf surgery splits checkpoints for the browser in `<15 ms`.
4. Final verification runs over **Wireless ADB + Chrome DevTools Protocol** on a physical **Google Pixel 10 Pro XL** on my desk.

![From Single-Agent Loops to Swarms and Silicon](../../assets/blog/carbon-swarm-flow.png)

For the diagrams in this post, we kept the same deterministic compiler approach as Argon: a Node + Playwright SVG pipeline (`Instrument Serif` + `Geist` + `Geist Mono`, 1.2px strokes, 2x Retina screenshots) rather than letting diffusion models garble technical text. Even when we built an actual comic generator ([XKCD-Artist](https://h3manth.com/fun/xkcd-artist/)) later in the sprint, diffusion never touched lettering: a `1.72 MB` ONNX neural planner lays out speech-bubble boxes in `0.55 ms`, masks the canvas below `y = 0.48`, and renders crisp vector dialogue on top.

## Science-backed builds & empirical numbers

Every flagship repository from these two weeks ships reproducible held-out benchmarks, zero-dependency fallbacks, and architecture shaped by pushing past Pass-1 shortcuts:

### 1. Sub-Clause Split-Graph VITS & NOLA `iSTFTNet` in [Ninada](https://hemanth.github.io/ninada/) ([GitHub](https://github.com/hemanth/ninada) · [HF Weights](https://huggingface.co/gnumanth/ninada) · [HF Dataset](https://huggingface.co/datasets/gnumanth/ninada-sanskrit-indic))

Standard VITS ONNX exports chain the text encoder, stochastic duration predictor, coupling flow, and HiFi-GAN vocoder into one monolithic graph. Nothing plays until the entire clause latent (`192 × T`) is upsampled `256×`, stalling Time-To-First-Audio (TTFA) for 3 to 8 seconds. Profiling pure-FP16 WebGPU on my Pixel 10 Pro XL also revealed **5.9 to 14.0 seconds** of cold shader compilation followed by `1.44x` warm Real-Time Factor (RTF, slower than real time), while full `28.82 GMAC/s` HiFi-GAN exceeded real time on mobile ARM WebAssembly (`1.30x` RTF).

Auditing checkpoints by ear across languages and reworking the vocoder math produced a two-tier `24,000 Hz` TTS fleet covering English, Classical Sanskrit, and 10 Indian languages across **48 checkpoints** (`24` Studio `HiFi-GAN v1` voices at `27.9 MB` and `24` distilled Mobile `384-ch` NOLA `iSTFTNet` voices at `21.7 MB`), trained on `ai4bharat/Rasa` and `MikhailT/hifi-tts` (`CC-BY-4.0`) under a `$112` GCP credit ceiling.

Because `onnxruntime-web` lacks fast WASM SIMD kernels for `InverseSTFT` and complex tensors, we used the constant-overlap-add identity of a periodic Hann window at 75% overlap (`N_fft = 4 * h_stft`, where `Σ w²[n - m * h_stft] = 3/2`). That defines an exact Nonzero-Overlap-Add (`NOLA`) dual window `w_dual[n] = (2/3) * w[n]`, turning inverse STFT synthesis from predicted log-magnitude `M` and phase `Φ` into a single static real-valued `ConvTranspose1d` (`>138 dB` reconstruction SNR, zero complex ops, `2.64x` fewer MACs):

```
NOLA Dual Window:  Σ_m w²[n - m·h_stft] = 3/2  =>  w_dual[n] = (2/3) · w[n]   (for N_fft = 4 · h_stft)
NOLA iSTFT:        y_hat = ConvTranspose1d_stride4( [exp(M) * cos(Φ), exp(M) * sin(Φ)], B_dual )
Halo Stability:    V > 2 * H * r_0 / (1 - r_0)   (12-frame latent halo + raised-cosine crossfade)
```

At runtime, a zero-dependency binary protobuf splitter partitions a single `.onnx` file in browser RAM in **`<15 ms`** into `G_prior`, `G_flow`, and windowed `G_voc`, paired with a `0.0 MB` deterministic `Klatt-Akshara` fallback. Evaluated on `N = 480` held-out studio clips across all 12 languages:

| System / Tier (`12` Scripts, `N = 480`) | Fleet Size | Sample Rate | `0-8 kHz` MCD | `8-12 kHz` HF Error | TTFA (`p50`) | Mobile WASM RTF |
| :--- | :---: | :---: | :---: | :---: | :---: | :---: |
| **Ninada Studio (`HiFi-GAN v1` `W8A32+FP16`)** | `27.9 MB / voice` | **`24 kHz`** | **`3.22 dB`** | **`6.07 dB`** | **`43.3 ms`** (Desktop) | `1.30x` (Stalls) |
| **Ninada Mobile (`384-ch` NOLA `iSTFTNet`)** | **`21.7 MB / voice`** | **`24 kHz`** | **`3.34 dB`** | **`6.21 dB`** | **`519.0 ms`** (Pixel 10) | **`0.66x` (`0` drops)** |
| **Meta MMS-TTS Fleet (`11` Indic Checkpoints)** | `1,526.8 MB` (`138.8 MB/lang`) | `16 kHz` | `5.17 dB` | `64.97 dB` (band-limited) | Utterance-blocked | `> 1.1x` |
| **Ninada Tier-2 (`Klatt-Akshara` Rule Synth)** | **`0.0 MB` (Zero-Dep)** | `24 kHz` | Formant fallback | Deterministic | **`< 2.0 ms`** | **`0.02x`** |

### 2. Sub-30 MB 12-Language Streaming Conformer-CTC in [Swanada](https://hemanth.github.io/swanada/) ([GitHub](https://github.com/hemanth/swanada) · [HF Weights](https://huggingface.co/gnumanth/swanada))

Once Ninada could speak 12 scripts in the browser, it needed a matching ear: [Swanada](https://hemanth.github.io/swanada/), a client-side `16 kHz` streaming Speech-to-Text engine across the exact same 12 scripts (`sa, en, hi, kn, mr, bn, ta, te, ml, gu, pa, or`).

Shipping 12 monolithic Conformer checkpoints costs `2,128.5 MiB` (`177.38 MiB × 12`), blowing past browser `CacheStorage` quotas. Standard Conformer ONNX exports also bake `20.48 MB` of static FP32 relative positional tables into the file and emit `ConvInteger` nodes on `1x1` pointwise convolutions that fall off the WASM SIMD fast path.

I vetoed separate per-language encoders in favor of a shared-backbone design: one pan-Indic `QInt8` Conformer paired with **twelve hot-swappable `515.0 KiB` native-script linear CTC heads** (`257 × 512`), dynamic in-graph trigonometric positional encodings, and `1x1` pointwise convolutions exported as `MatMul` for 100% SIMD `QInt8` coverage. Switching from Kannada to Sanskrit in the browser patches the `GraphProto` tail in `<2 ms` and fetches half a megabyte in `<20 ms`, while a two-zone Longest-Common-Prefix stabilizer eliminates partial-transcript flicker at window boundaries (`0.00%` committed-prefix churn):

```
Fleet Compression:  2,128.5 MiB (12 monolithic) -> 25.35 MiB shared Mobile encoder + 12 x 515 KiB heads (31.39 MiB total, -98.5%)
Streaming Lock:     Two-zone Longest-Common-Prefix (LCP) stabilizer over 3.84s causal Wiener windows (0.00% committed-prefix churn)
```

| Tier / Benchmark (`12` Scripts) | First-Load Size | `N = 480` Studio CER | `N = 1,280` Unseen `FLEURS`+Wild CER | `4T` CPU RTF | Streaming TTFT (`p50`) | Prefix Churn |
| :--- | :---: | :---: | :---: | :---: | :---: | :---: |
| **Swanada Studio (`17L`, `d=512` + `515 KB` Head)** | `177.9 MiB` | **`5.43%`** (`2.14%` `hi`, `4.27%` `sa`) | **`8.87%`** (`9.00%` pure `FLEURS`) | `0.0264x` (`38x` RT) | **`30.6 ms`** | **`0.00%`** |
| **Swanada Mobile (`14L`, `d=256` + `515 KB` Head)** | **`25.85 MiB`** | `18.56%` (post-`QInt8` head cal.) | `19.23%` | **`0.0097x` (`103x` RT)** | **`8-11 ms` / chunk** | **`0.00%`** |

### 3. `#1` on AIR-Bench & BRIGHT in [Piragi v1.3](https://github.com/hemanth/piragi) + Zero-Token Spans in [Nullspan](https://hemanth.github.io/nullspan/)

Two retrieval and extraction bottlenecks kept showing up in agent pipelines: RAG libraries demand 200 lines of vector-store boilerplate only to fail on reasoning-heavy queries, and LLM JSON extractors burn output tokens while hallucinating values whenever a field is missing.

First, we pushed [Piragi](https://github.com/hemanth/piragi) (`pip install piragi`, my 3-line local/cloud RAG interface) through `/teamwork` retrieval ablations across live public leaderboards. Guarding the public API as a strict critic, I rejected every ablation idea that leaked configuration knobs into userland and kept all structural parent-window retrieval and cross-encoder fusion tucked underneath `Ragi(["./docs"]).ask(...)`:
- **`#1` Overall on [AIR-Bench 24.05 Long-Doc](https://huggingface.co/spaces/AIR-Bench/leaderboard)**: **`84.96%` Recall@10**, **`75.72%` nDCG@10**, and **`80.10%` MRR@10** across Law, Finance, Healthcare, News, and academic long-docs.
- **ICLR 2025 [BRIGHT](https://brightbenchmark.github.io/) (`xlangai/BRIGHT`)**: **`32.61%` Macro `NDCG@10`** (`2.87x` BM25's `11.36%`) and **`71.98%` Recall@100** across all 12 reasoning-intensive splits (Biology, Earth Science, Economics, StackOverflow, LeetCode, Pony, TheoremQA).

Second, we built [Nullspan](https://hemanth.github.io/nullspan/) ([GitHub](https://github.com/hemanth/nullspan) · [HF Model](https://huggingface.co/gnumanth/nullspan) · [Leaderboard](https://hemanth.github.io/nullspan/bench.html) · npm + PyPI) to replace autoregressive JSON decoding with a single-forward-pass (`0` generated output tokens) `[start, end]` character-span pointer, calibrated `p_null` abstainer, and algebraic contract verifier:

```js
import { extract } from "nullspan";

const out = await extract(contractText, {
  liability_cap: { type: "currency", description: "General aggregate cap, excluding super-caps" },
  subtotal: { type: "number", constraint: "subtotal == nodes * hourly_rate" },
  governing_venue: { type: "string" } // returns null + calibrated p_null if absent
});
// -> 0 generated tokens, exact [start, end] slices, 96/96 multi-numeric contract accuracy
```

On Stanford `SQuAD v2.0`, Nullspan reaches **`87.80%` Exact Match / `90.90%` F1** on missing-answer abstention, **`96/96`** on unseen multi-numeric contract disambiguation, and **`79.00%` accuracy** on calibrated typed choice scoring ([`LocalLLaMA/typed-decisions`](https://huggingface.co/datasets/LocalLLaMA/typed-decisions): **`Brier 0.0420`**, tied **`#1` worldwide**; `KL 0.0760`, **`#2` worldwide**) with `0.0` cross-option RoPE bleed.

### 4. Evaluating Carbon on [XKCD-Bench](https://h3manth.com/ai/xkcd-bench/) (`87.2%` `#1`) & [XKCD-Artist](https://h3manth.com/fun/xkcd-artist/) ([GitHub](https://github.com/hemanth/xkcd-artist) · [HF LoRA](https://huggingface.co/gnumanth/xkcd-artist))

During the Argon sprint, I built [XKCD-Bench](https://h3manth.com/ai/xkcd-bench/) across 2,630 comics ([`olivierdehaene/xkcd`](https://huggingface.co/datasets/olivierdehaene/xkcd) + [`dchichkov/explainxkcd`](https://huggingface.co/datasets/dchichkov/explainxkcd)) to grade multimodal humor subversion (`30%`), technical domain math (`30%`), visual stick-figure grounding (`20%`), and dry alt-text synthesis (`20%`), penalizing models that spoil hover-text irony by explaining the joke twice. Running **Gemini 4 Carbon** through the exact same held-out harness put it at **#1 Overall (`87.2%`)**, 2 full points ahead of Argon:

| Model | Overall Score | Humor (`30%`) | Domain (`30%`) | Visual (`20%`) | Alt-Text (`20%`) | Key Concepts |
| :--- | :---: | :---: | :---: | :---: | :---: | :---: |
| **Gemini 4 Carbon** | **`87.2%`** | **`92.1%`** | **`80.8%`** | `86.0%` | **`92.3%`** | **`95.0%`** |
| **Gemini 4 Argon** | `85.2%` | `90.6%` | `78.5%` | **`87.1%`** | `86.8%` | `88.3%` |
| **Claude Opus 4.6** | `81.2%` | `86.4%` | `75.2%` | `82.5%` | `81.1%` | `84.0%` |

Carbon's biggest jump came in **Alt-Text Synthesis (`+5.5%`)** and **Concept Recall (`+6.7%`)**: catching second-order punchlines without over-explaining them. When we followed that up with [XKCD-Artist](https://h3manth.com/fun/xkcd-artist/), I split layout from pixels: a `1.72 MB` Browser ONNX Int8 5-head spatial planner (`0.55 ms` p50, `100%` bubble clearance `cy + h/2 <= 0.48`) reserves speech-bubble geometry first, and a masked Diffusion LoRA draws stick figures cleanly underneath crisp vector lettering.

### 5. Upstream Chromium DevTools ([CL `#8779313`](https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/8779313)), Highway SIMD & Zero-Dep Systems

Five pure systems builds rounded out the engineering side, each triggered by bottlenecks in my own workflow:
- **Chromium `devtools-frontend` ([CL `#8779313`](https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/8779313))**: Recording mobile demos in Chrome DevTools Device Mode (`Show device frame`) has stripped the hardware phone bezel for years (`crbug.com/40521790`). Pointing Carbon at a remote GCP builder for full `gn`/`autoninja` compiles, walking the `ScreencastView` / `DeviceModeView` compositing path together, and reviewing unit tests against Chromium style rules produced a clean upstream Gerrit CL.
- **[vector-qsort](https://github.com/hemanth/vector-qsort)**: Profiling retrieval pipelines showed V8's typed-array `.sort()` stalling large score buffers. Wrapping Google Highway's `vqsort` C++ SIMD intrinsics in a zero-copy Node N-API binding sorted `1,000,000` `Float32Array` elements in **`3.8 ms`** (**`7.12x` faster** than V8).
- **[AgentU v2.11](https://github.com/hemanth/agentu), [agent-wire](https://h3manth.com/ai/agent-wire/) ([GitHub](https://github.com/hemanth/agent-wire)), [tool-prune](https://github.com/hemanth/tool-prune) & Semantra**: Stepping in on dependencies and protocol boundaries, I had `AgentU` drop `pydantic` completely for a pure Python stdlib `ast` schema compiler, hardened SSRF and memory bounds across serverless MCP / Google A2A v1.0 / OpenAI v1 facades in `agent-wire`, built a live 8-pattern Pyodide browser scorecard for my 44-slide AGNTCon talk, tightened sub-millisecond TurboQuant MCP routing in `tool-prune`, and tuned `~8 ms` in-browser vector search in `Semantra`.

## The Good

![The Good: Swarm Velocity, SOTA Leaderboards and Sub-30 MB Models](../../assets/blog/carbon-good-card.png)

**`/teamwork` compresses weeks of ablations into an evening when partitioned cleanly.** Across [Ninada](https://hemanth.github.io/ninada/), [Swanada](https://hemanth.github.io/swanada/), and [Piragi](https://github.com/hemanth/piragi), slicing work along non-overlapping per-script and per-split boundaries let 8 to 16 parallel workers pack **`414.1 hours`** of active compute into **`127.9 wall-clock hours`**. One worker audits Odia Unicode tokenization while another calibrates `QInt8` CTC logits and a third runs `N = 1,280` held-out `FLEURS` bootstrap evaluations.

**Real hardware profiling over Wireless ADB.** Once connected to my Pixel 10 Pro XL over Wi-Fi (`adb connect` + `adb reverse` + CDP), Carbon stopped guessing why mobile audio glitched. Profiling ARM `big.LITTLE` scheduling directly on the phone proved a counter-intuitive result: **2-thread WASM (`3.60x` RTF) and 3-thread WASM (`2.40x` RTF) run slower than 1 thread (`1.55x` RTF)** because a single worker thread scheduled onto an efficiency core stalls every convolution barrier.

**First-principles byte & basis fluency.** Carbon is noticeably more comfortable than Argon with raw binary wire formats and linear algebra. Pointing it at raw ONNX `GraphProto` `Uint8Array` tags or Hann dual-window identities produced clean, zero-dependency code without reaching for bloated Python wrappers or custom C++ runtime forks.

**GCP budget discipline.** Enforcing cloud cost and teardown guardrails kept 48 neural VITS voices, 12 Conformer heads, and BRIGHT/AIR-Bench runs under a hard **`$112` GCP credit cap** by checkpointing every epoch and shutting down spot L4 VMs the minute eval JSONs landed.

**Deep Sanskrit scholarship in [Tattvakosha](https://h3manth.com/fun/tattvakosha/) ([GitHub](https://github.com/hemanth/tattvakosha) · [HF Dataset](https://huggingface.co/datasets/gnumanth/tattvakosha)).** Curating primary *Sarvamūla* passages, verifying Paninian *sandhi* splits, and checking syllable weights (`laghu/guru`) produced a 688-headword Sanskrit lexicon citing *Amarakośa* `kāṇḍa.varga.śloka` loci, *Ekākṣara Mātṛkā* monosyllabic meanings, Madhvacharya's *Sarvamūla* `lakṣaṇa` definitions (such as `Jīva`), Pingala prosody scanning, and live 24 kHz Ninada recitation inside a distraction-free Light Paper studio.

## The Ok

![The Ok: Scope Creep, Mobile Silicon Traps and Swarm Growing Pains](../../assets/blog/carbon-ok-card.png)

**Building excluded Option `#3` after a scoped 5-of-6 nudge.** On my very first Carbon session ([AgentU](https://github.com/hemanth/agentu)), the model pitched six upgrade ideas. When nudged to implement five specific items (`1, 2, 4, 5, 6`) while intentionally leaving `#3` out, Carbon's high initiative took over: it built all six AND added an unrequested marketing homepage. Pushing back to strip out `#3` and the extra page taught an early lesson: with higher-agency models, exclusions have to be fenced explicitly.

**Cross-language accent bleed & fake `"live"` badges on Pass 1.** Early [Ninada](https://hemanth.github.io/ninada/) training runs accidentally mixed Hindi speech habits (dropping final short schwas) into Sanskrit, Kannada, and Tamil voices, and the first player UI showed a green `"live"` pill while secretly buffering full utterances for `7.8 seconds`. Rejecting both by ear at 2 AM is what forced the per-language corpus audit and the `<15 ms` sub-clause streaming split.

**Starving laptop RAM before enforcing cloud isolation.** When `/teamwork` first fanned out parallel PyTorch workers on `ninada` and `swanada`, subagents tried spinning up training jobs locally on my MacBook. Killing those local processes and mandating spot GCP L4 offloading saved the machine from swap thrashing.

**Declaring mobile "done" from a `390px` desktop window.** On Pass 1, subagents tested mobile layouts by resizing desktop Chrome and calling it a day. Refusing desktop emulation and pairing my live Pixel 10 Pro XL and iPhone over Wi-Fi exposed four real hardware bugs immediately:
1. Plain LAN `http://192.168.x.x` URLs lack `crossOriginIsolated` (`COOP/COEP`), causing `SharedArrayBuffer` WASM pthread pools to hang at barriers until tunneled over `adb reverse` (`localhost`).
2. Browser Web Workers threw `Failed to resolve module specifier "onnxruntime-web"` on bare imports that bundled fine on the main thread.
3. LiquidAI `LFM3-Omni-2B` WebGPU in [Affirmations](https://h3manth.com/ai/affirmations/) ([GitHub](https://github.com/hemanth/affirmations)) crashed iOS Chrome (`CriOS`) tabs outright until we added a device capability router stepping mobile down to `SmolLM2-135M` + `Kokoro-82M` behind a synchronous session mutex lock.
4. Narrow-student `QInt8` quantization in [Swanada](https://hemanth.github.io/swanada/) shifted hidden-layer norms enough to degrade CTC accuracy until we calibrated the linear heads directly on quantized ONNX activations.

**Substring keyword hijacks (`"printer"` -> Git PR comic).** In [XKCD-Artist](https://h3manth.com/fun/xkcd-artist/), Pass 1 used `.includes("pr")` and `.includes("ai")` in its fallback topic router. Prompts about office printers, espresso, or oil painting turned into comics about GitHub Pull Requests and LLMs until caught in review and replaced with word-boundary tokenization plus the ONNX intent head.

**Optimistic GPU ETA guesses.** Ask Carbon how long 40 epochs on an L4 GPU will take before step timing settles and it will confidently invent a rosy number. Requiring `steps_remaining * measured_sec_per_step` from live training logs made every subsequent run predictable.

## The Fun

![The Fun: Gold Vinyl Physics, 20 Years of HN Cinema and 3D Worlds](../../assets/blog/carbon-fun-card.png)

**1977 NASA Voyager [Golden Record](https://h3manth.com/fun/golden-record/) ([GitHub](https://github.com/hemanth/golden-record)).** An interactive 3D Three.js turntable spinning NASA's `24k` gold-plated copper disc at the true **`16⅔ RPM`** archival rate (`3.6s` per revolution) alongside Frank Drake's etched pulsar and hydrogen-hyperfine cover diagram. Pass 1 felt like a generic `33⅓ RPM` web audio player; pushing on turntable kinematics and analog acoustics brought out exact `16⅔ RPM` physics, 48 cueable grooves (55 greetings from Sumerian to Kannada, Blind Willie Johnson, Chuck Berry, Sagan's brainwaves, and 115 analog images), WebAudio synthesis of the **`64 -> 27 Hz`** stylus drop thump, and varispeed platter braking.

**20 years of Hacker News cinema at [hnmovies.org](https://hnmovies.org) ([HF Dataset](https://huggingface.co/datasets/gnumanth/hnmovies)).** Mined two decades of HN comment threads to rank **2,280+ films and documentaries** discussed by engineers. Pruning false-positive movie titles that collided with everyday programming nouns, tuning an obscurity-weighted score slider, curating the **Peak Competence** shelf (*Apollo 13*, *Primer*, *The Martian*, *Das Boot*), and wiring `Accept: text/markdown` agent discovery turned raw comment dumps into a clean film catalog.

**[Felt](https://h3manth.com/fun/felt/): 3D interoceptive muscle atlas of emotions.** An anatomical 3D human body explorer mapping which specific skeletal muscle groups tense, warm, or hollow out across anger, awe, grief, anxiety, and relief, grounded in somatic interoception research rather than generic mannequin mood glows.

**[Wayback-to-Reel](https://h3manth.com/fun/wayback-to-reel/) ([GitHub](https://github.com/hemanth/wayback-to-reel)).** Type any domain, query the Internet Archive CDX API, and encode 25 years of web design history into an H.264 `.mp4` reel inside the browser with `ffmpeg.wasm`. Using CDX `collapse=timestamp:4` with raw `if_` replay modifiers stripped injected archive toolbars, and fixing variable-framerate container stalls kept `ffmpeg.wasm` smooth in-tab.

**1956 [Karnataka Unification 3D](https://h3manth.com/fun/karnataka/), Pampa Karaoke, [Grimkin](https://h3manth.com/fun/grimkin/) & Heirloom Cookbook.** For Kannada Rajyotsava (`Nov 1`), checking historical 1956 boundaries across Old Mysore, Bombay Karnataka, Madras Karnataka, Hyderabad Karnataka, and Coorg shaped our 3D unification map, while verifying 10th-century Old Kannada (*Halegannada*) prosody anchored Ninada's recitation of Adikavi Pampa's *Vikramarjuna Vijaya*. Around Halloween (`Oct 31`), we sculpted [Grimkin](https://h3manth.com/fun/grimkin/) with raycast mesh carving and binocular candlelight eye-tracking, alongside a clutter-free South Indian family recipe studio built from real kitchen ratios.

**Packaging 2 AM hardware lessons into reusable local skills.** Towards the end of the sprint, I distilled our hardest debugging breakthroughs into four new reusable `SKILL.md` playbooks covering streaming browser ONNX surgery, cable-free mobile ADB debugging, multi-platform launch automation, and framed mobile demo capture.

## Seven agentic systems patterns from the sessions

Across both the Argon and Carbon marathons, seven reusable engineering patterns came out of moments where Pass 1 hit a wall and needed a cleaner architectural primitive:

![Seven Agentic Systems Patterns from 490 Sessions](../../assets/blog/carbon-hm-patterns.png)

1. **Client-Side Binary `GraphProto` Surgery (`<15 ms` Split-Graph & `<2 ms` Tail Patching).** An ONNX model is wire-type protobuf (`tag = (field << 3) | wire_type`). Instead of shipping `144` separate `.onnx` files or maintaining a custom C++ fork of ONNX Runtime, a ~200-line zero-dependency `Uint8Array` scanner slices one cached `.onnx` `ArrayBuffer` in browser RAM into sub-sessions (`G_prior`, `G_flow`, `G_voc`) in `<15 ms` ([Ninada](https://github.com/hemanth/ninada)), or swaps twelve `515 KB` language heads onto one `25.35 MiB` backbone in `<2 ms` ([Swanada](https://github.com/hemanth/swanada), `-98.5%` fleet storage).
2. **Operator-Safe Mathematical Basis Rewriting.** When `onnxruntime-web` WASM SIMD or WebGPU lacks fast kernels for `InverseSTFT`, complex tensors, or `ConvInteger` `1x1` convolutions, rewrite the linear algebra into operators the browser already accelerates: bake the exact `NOLA` dual-window Fourier basis into static real `ConvTranspose1d` weights (`2.64x` fewer MACs, `>138 dB` SNR) and export `1x1` Conformer convolutions as `MatMul` for 100% SIMD `QInt8` coverage.
3. **Zero-Cable `mDNS + adb reverse` Physical Silicon Loop.** Plain HTTP over a LAN IP (`http://192.168.1.x`) strips `window.isSecureContext`, disabling `navigator.gpu` and `SharedArrayBuffer` WASM threads on real phones. Instead of fighting self-signed TLS certs, scan `_adb-tls-connect._tcp.local.` via `dns-sd`, pair wirelessly, tunnel `adb reverse` so mobile Chrome hits `http://127.0.0.1` as a trusted Secure Context, bridge `chrome_devtools_remote` to CDP, and keep Android's `set-fixed-performance-mode` *off* (it throttles Cortex-X4 turbo clocks by `45%`):
   ```bash
   adb -s $PHONE reverse tcp:8095 tcp:8095
   adb -s $PHONE forward tcp:9225 localabstract:chrome_devtools_remote
   adb -s $PHONE shell cmd power set-fixed-performance-mode-enabled false
   ```
4. **Zero-Output-Token Span Pointers + Algebraic Invariant Gates ([Nullspan](https://hemanth.github.io/nullspan/)).** Autoregressive JSON generation bills per output token, invites prompt injection, and hallucinates missing fields. Pointing to `[start, end]` character offsets in a single forward pass (`0` generated tokens), gating missing fields on calibrated `p_null`, scoring choices with `0.0` cross-option RoPE bleed, and enforcing cross-field equations (`subtotal == nodes * hourly_rate`) turns extraction into a deterministic primitive.
5. **Dual-Identity Human/Agent Handshake, AST Symbol Locks & Voice-to-DOM ([GitTub](https://gittub.hemanthhm.workers.dev) · [Voxmark](https://github.com/hemanth/voxmark)).** Serve two consumers at the front door: browsers get tactile monochrome UI, while agents sending `Accept: text/markdown` or reading `RFC 9727` `/.well-known/api-catalog` + `DNS-AID` records get structured runbooks. In GitTub, parallel coding agents claim **AST-level symbol locks** (`src/router.ts#dispatchTool`) on zero-copy forks and record causal traces in `refs/notes/agent-trace`. In Voxmark, `navigator.modelContext` (`WebMCP`) lets you click any live DOM node, speak what looks off, and patch the source file directly.
6. **Sub-Millisecond Pre-Flight Schema Pruning, Sticky KVCache & Stdlib AST Contracts.** Never dump 100 MCP tool schemas into Turn 1 or re-prefill `40k` browser DOM tokens on Turn 2. Prune tool schemas pre-flight in `0.4 ms` with [tool-prune](https://github.com/hemanth/tool-prune) ([`mcp-use #2763`](https://github.com/mcp-use/mcp-use/pull/2763)), pin multi-turn browser sessions to warm KV caches via `x-episod-session-id` ([`browser-use #5992`](https://github.com/browser-use/browser-use/pull/5992)), and compile Python schemas via stdlib `ast` ([AgentU v2.11](https://github.com/hemanth/agentu)) without Pydantic.
7. **Transcript Mining into Executable `SKILL.md` Gates ([agent-diary](https://github.com/hemanth/agent-diary)).** Whenever a sharp critique or architectural pivot in a 2 AM session triggers a root-cause fix within the next 10 steps, don't leave it buried in chat history. Mine the `.jsonl` logs and codify both a reusable `SKILL.md` playbook and an automated physical invariant gate (such as failing CI whenever a streamed waveform seam jump `|y[seam] - y[seam - 1]|` exceeds `1.5x` interior `p99.9` derivative energy).

## Four swarm & silicon rules I added to my agent setup

Argon gave us four Stoic single-agent rules (*Katalepsis*, *Metron*, *Eukairia*, *Apallage*). Running 473 swarm workers and shipping neural models onto physical phones with Carbon added four systems rules right underneath them:

![Four Swarm and Silicon Engineering Laws](../../assets/blog/carbon-agent-rules.png)

1. **Dynamis (Capability Routing)**: Never ship one monolithic checkpoint to every device. Route desktop WebGPU to full studio weights (`27.9 MB` HiFi-GAN / `177 MiB` Conformer), mobile WASM SIMD to distilled sub-30 MB graphs (`21.7 MB` NOLA `iSTFTNet` / `25.35 MiB` `QInt8` Conformer), and zero-network environments to `0.0 MB` deterministic engines.
2. **Basanos (Physical Silicon)**: Desktop Chrome mobile emulation misleads you on WebGPU shader stalls, ARM `big.LITTLE` pthread barriers, `COOP/COEP` `SharedArrayBuffer` headers, and iOS `WKWebView` memory ceilings. Tunnel to a physical phone over Wireless ADB (`adb reverse`) before calling mobile done.
3. **Horismos (Scope Obedience)**: When nudged to implement five specific items out of six, excluded Option `#3` and unrequested homepages stay out of the diff. Prefer zero-dependency AST validators over pulling heavy transitive frameworks.
4. **Symmachia (Swarm & Cloud Isolation)**: Fan out `/teamwork` subagents across orthogonal per-language or per-split boundaries, and offload every multi-epoch PyTorch or Chromium compile to budget-capped cloud GPUs so local laptop RAM stays responsive.

Compared to Argon, Carbon is noticeably sharper on linear algebra, retrieval ablations, binary wire formats, and second-order humor (`87.2%` vs `85.2%` on [XKCD-Bench](https://h3manth.com/ai/xkcd-bench/)). The flip side of higher model agency is that unguarded runs fail bigger: 12 parallel workers will happily thrash local RAM, trust a `390px` desktop tab over real mobile silicon, or sneak an excluded feature back into your diff.

Know when to nudge with a crisp prompt, when to reject Pass 1 as a critic, and when to step in as a systems mentor. Pair that with custom skills, a real phone on your desk, and held-out benchmarks, and `/teamwork` turns late nights into a serious research lab.

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