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

Right after shipping 24 projects on Gemini 4 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 and XKCD-Bench (87.2%), published 60+ open weights and datasets to Hugging Face, and uploaded an upstream Chromium DevTools CL (#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 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 (14,949 steps + 211 primary workers), Swanada (5,711 steps + 189 workers), Nullspan (4,695 steps, 16.6 hrs)

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.

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) 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 (GitHub · HF Weights · HF Dataset)

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 (GitHub · HF Weights)

Once Ninada could speak 12 scripts in the browser, it needed a matching ear: 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 + Zero-Token Spans in 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 (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: 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 (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 (GitHub · HF Model · Leaderboard · 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:

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: Brier 0.0420, tied #1 worldwide; KL 0.0760, #2 worldwide) with 0.0 cross-option RoPE bleed.

4. Evaluating Carbon on XKCD-Bench (87.2% #1) & XKCD-Artist (GitHub · HF LoRA)

During the Argon sprint, I built XKCD-Bench across 2,630 comics (olivierdehaene/xkcd + 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, 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), 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): 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: 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, agent-wire (GitHub), 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

/teamwork compresses weeks of ablations into an evening when partitioned cleanly. Across Ninada, Swanada, and 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 (GitHub · HF Dataset). 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

Building excluded Option #3 after a scoped 5-of-6 nudge. On my very first Carbon session (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 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 (GitHub) 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 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, 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

1977 NASA Voyager Golden Record (GitHub). 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 (HF Dataset). 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: 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 (GitHub). 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, Pampa Karaoke, 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 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:

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), or swaps twelve 515 KB language heads onto one 25.35 MiB backbone in <2 ms (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%):

   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). 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 · 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 (mcp-use #2763), pin multi-turn browser sessions to warm KV caches via x-episod-session-id (browser-use #5992), and compile Python schemas via stdlib ast (AgentU v2.11) without Pydantic.
7. Transcript Mining into Executable SKILL.md Gates (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:

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