Twenty-seven builds, and what each one cost.

Free inference makes a noisy model affordable, not correct.

A 24/7 code reviewer running on an 8B model on a Mac mini, audited periodically by Claude Opus. Over 714 hours it completed 8,826 review runs across 2480 versions of 1291 files in two repositories and pushed 24.88 million prompt tokens through the local model at no marginal cost. The paid audit has graded 715 of its findings, upheld 12, and rejected 703. That gap is the point of the project rather than a footnote to it: local inference solves cost and privacy, and solves nothing about quality. A month ago the same ratio read 3 of 182, so roughly four times the volume has bought no improvement in precision at all. The design earns its keep by letting the model be wrong cheaply. A free, no-model grounding filter discards findings that quote code which is not in the file, so 572 of them cost nothing to reject, and only what survives four filters reaches the layer that bills. The steward that reclaims memory suspends processes rather than ending them, and four capabilities (deleting files, uninstalling apps, changing system settings, ending processes) cannot be granted through any interface.

A model writes the agent. Git is the undo.

The agent factory inside anthill. A person types what they want done, a cloud model plans it, writes it, and the result lands in the repository. The entire safety argument is one property, and it is a test rather than a promise: a generated agent is merged but never scheduled. Merging is reversible, so a bad agent is one revert away; scheduling is not, so the machine is never given it. Two tests in test_register.py hold that line, named so nobody has to read the implementation to know what they guarantee. The planner and the builder are separate programs: the queen only produces a plan a human approves, holds no authority, and writes no files. The step between them names itself the trust boundary, because a model running with actions disabled is safe as an actor while what it returns is a different problem entirely, so every build-shaped field it hands back is machine-verified or refused. The acceptance gate returns the failure text rather than a boolean, since that text is what a bounded retry feeds back to the model that wrote the agent. Three agents written this way are in the repo now, each answering a question about this machine: which files fill Downloads and which are copies, what starts without being asked, and what sits uncommitted across every repo.

Tune the agent without shipping the app.

A local harness lab for G, the assistant inside GBuild. It exists because a Cloudflare build took most of an hour and the thing being iterated on was a persona file, so the edit-to-observation loop was set by a compiler rather than by the change. The lab runs the installed app’s own engine against a swappable home directory: edit the persona, and the very next run reads it, with no rebuild and no release. What makes it an instrument rather than a playground is the null baseline. A stochastic engine gives different answers to the same prompt, so “the two arms differ” can never justify keeping anything; the soul A/B therefore runs three arms, two of which are deliberately identical, and an overlay has to beat the engine’s own run-to-run noise before it counts as having done something. Grading is left to a human on purpose, because an automated judge would be a second unmeasured layer scoring the first. The parity manifest the lab reads is generated from the production Rust source, so the lab cannot quietly drift into testing something the app does not do.

An agent can get a wallet in an afternoon and a name never.

By mid-2026 an autonomous agent can get a wallet and a payment protocol off the shelf, but name and reachability (domain, DNS, mailbox, phone number) are still human-gated and priced for enterprise SaaS. This is the four-organ stack that closes the gap for GBuild’s agent: its own inbox on Cloudflare Email Routing (with inbound treated as hostile input and scrubbed of secret-shaped material before storage), its own Telnyx number brokered so no telephony credential reaches the device, its own domain via Latch, and a Stripe Issuing card whose budget is enforced by spending controls set at mint rather than by our uptime. The shaping constraint: the agent may read its identity but cannot mint its own card or write its own DNS. Both are human-plane only, pinned by tests. The card path is TEST mode and the proactive capability loop is deliberately inert.

Connect any domain, no human at the registrar login.

DNS automation for SaaS onboarding, built rather than licensed because every product in the category assumes a person is present to click approve inside a registrar modal. Latch detects where a domain’s DNS is hosted, writes the records where it holds credentials, falls back to a guided manual flow where it does not, and verifies propagation server-side across multiple DNS-over-HTTPS resolvers. The engineering that matters is email DNS: merging into the single permitted SPF record instead of adding a second, preserving the original all qualifier, refusing at the 10-lookup ceiling rather than silently flattening includes, and hard-stopping on any existing MX rather than quietly taking down someone’s inbox. A zero-dependency TypeScript engine runs identically in tests and on Workers. Deployed at latch.gbuild.app.

Build anything. Smarter.

A macOS desktop app that orchestrates a fleet of AI coding agents through 5 first-party drivers (Claude Code, OpenClaw, Hermes, Codex, shell + sandboxed bring-your-own) from one calm, voice-first interface. One shell: Lattice, a voice-first command bar whose power surfaces (Mission Control, AI Video Studio, ThingStore) ship as native Apps inside it; the legacy second shell was deleted in a 26,000-line single-shell consolidation. Electron plus a Rust sidecar over JSON-RPC (1045 registered methods), an on-device voice pipeline (MLX Whisper STT, Kokoro TTS, Gemini Live realtime), a fully local Qwen3 RAG layer, bidirectional Obsidian sync, full MCP lifecycle management, and the "G" mascot. 7,901 commits and 344 notarized releases in its first 121 days. Its research arm, the Semiochemical Context Layer, compresses agent protocols into roughly 1-token pheromone codes. Marketing site live at gbuild.app; the desktop app is in private development.

An operating system you can talk to.

GBuild's voice layer: dictation, conversational, and realtime modes over OpenAI Realtime and Gemini Live (3.1 Flash Live), with on-device MLX Whisper STT and Kokoro TTS. An intent router turns speech into tool calls that operate macOS apps, files, and folders, GBuild itself, and the agent fleet, behind destructive-intent confirmation and transcript redaction. Trained in a custom Voice Harness Lab where per-turn human feedback on real conversations becomes an approved patch to the harness source, plus a training center of scripted voice skits and router benchmarks. A proactive agent completes a PRD and CRM records live from a running conversation; phone-calling agents are deployed internally in a test environment.

A marketplace that verifies before it trusts.

A signed, sandboxed app marketplace for AI-built software, inside GBuild. Every publish clears a 5-layer automated gate (manifest schema validation, secret/PII scan, capability-ceiling lint, static CSP analysis, LLM risk review) plus egress-allowlist scrutiny; every install verifies an Ed25519 publisher signature over a SHA-256 content hash before a byte runs. Installed apps live in their own Electron session partition with deny-by-default permissions, and their only network path is a loopback CONNECT broker that resolves DNS internally to block rebinding. Revocation holds even offline. Supply-chain security for an app store, built solo.

Models that earn their way into the product.

GBuild's on-device model line. ModernBERT/DeBERTa encoder classifiers fine-tuned on synthetic data generated by typed-field corruption (so the training data costs nothing), evaluated against human-labeled gold sets, and promoted only past a paired-bootstrap 95% LCB significance bar with a champion/challenger harness. The first shipped model is a Rust runtime contact ranker with a versioned feature contract to its Python trainer and a Spearman rank-correlation gate. The keystone grounding verifier scored 97.5% on its own synthetic holdout and 62% on the gold set, a 35-point overfit the gates caught, published rather than hidden.

From conversation to shipped app.

The no-code on-ramp inside GBuild: a conversational interview (greeting → discover → suggest → stage → cherry-pick → cross-check → review → produce) that turns "what do you want to make" into a live PRD plus five supporting docs, persisted atomically, then hands off to a builder agent seeded with the export. The interview happens in a React-Three-Fiber 3D room with four interviewer personas, mode-choreographed cameras, and a WebGL/WebGPU backend selector.

The edge backend behind the desktop.

An 18-Worker Cloudflare service mesh behind one API gateway: passwordless magic-link identity with 4-provider OAuth2 + PKCE built from primitives, a key-custody LLM proxy with tier-aware daily dollar ceilings, queue-metered usage accounting into Postgres, Durable Object WebSocket hubs, SMS/voice telephony over Telnyx with Ed25519-verified webhooks, crash and telemetry sinks on R2, and an autonomy engine governed by off-switches, cooldowns, and circuit breakers. Zero-hop Service Bindings between Workers; workers.dev bypass disabled as a security control.

Pheromones, taught to AI agents.

The research arm of GBuild. A pheromone-inspired language that lets an AI agent decode a 1-token code into a full behavioral protocol, the way an ant's antenna turns one molecule into a fixed action. Three inventions (PHEROCODE, STIGFIELD, KAIROGRADIENT) over one shared decoder, the Antenna, held to a lab that measures a compression x fidelity frontier instead of a headline. Research v0.1: honest about where decoding holds and where it breaks, with live wiring into GBuild a deliberate next step.

Making the Invisible, Visible.

A full-stack mobile app connecting communities through interactive, real-time prayer mapping. Features a 6-dashboard command center with AI behavior monitoring, CRM pipeline, and RAG training controls.

A world ranking for the 200+ mile ultra.

A data-driven, weekly world ranking system for ultramarathon runners, launching with the 200+ mile tier. A pure-TypeScript engine (course-difficulty model, iterative field strength, time-decayed weighted-mean ratings, backyard scoring) over a Supabase backend with 11 migrations, RLS on 20+ tables, 6 edge functions, and a Monday recompute cron. A Next.js web app, a separate admin panel, and an Expo mobile app. Built with my dad as the domain expert. Live in preview; public launch pending.

Production infrastructure for AI agents.

An open-source infrastructure layer for Claude Code with 14 interactive skills, 7 specialized agents, a Smart MCP Loader that auto-enables servers via NLP scoring, and 48 scaffolding templates. Built entirely with Claude Code.

Adaptive thinking allocation.

A zero-dependency prompt scoring engine that classifies every Claude Code prompt on a complexity × stakes matrix, recommending one of 11 model/effort tiers from haiku/low to opus/max. Adversarial-tested with 183 passing tests.

Mission control for an autonomous agent fleet.

A real-time mission control dashboard monitoring an autonomous agent fleet across job search, project maintenance, and infrastructure.

Mission control framework.

The underlying framework powering Directors Chair. Provides agent lifecycle management, pipeline orchestration, persistent state, and multi-operator support. Built with Next.js, Supabase, Qdrant, and Discord. Private beta, with open-source release planned.

Privacy-first video editing.

A professional video editor built with Swift, Metal, and CoreML: 66 Metal compute kernels and 7 on-device AI engines. All AI processing runs locally on the Apple Neural Engine.

Ryder Cup for your crew.

A multi-platform golf tournament app with AI-powered caddie, ESPN-style broadcast leaderboards, and format-per-segment flexibility. Built for Apple Watch, Garmin, and mobile.

The planet, alive.

A WebGPU-powered globe visualization rendering live aircraft, satellites, ships, weather, and prayer energy at 60fps. GPU-computed boid flocks and particle simulations on mobile via react-native-wgpu.

AI Meets WordPress.

A LangGraph-based architectural prototype for multi-agent WordPress analysis. Orchestration harness and realtime Cursor-to-Pinecone sync are live; 27 agent personas defined in Postgres.

Multi-agent orchestration, extracted from production.

An AI orchestration framework extracted from the MCP-WP prototype. Coordinates Claude Code, Cursor, GitHub, Pinecone, LangSmith, and Slack into a unified development pipeline with file-based agent coordination.

Print preflight for Canva.

A Canva app that catches print production issues before they cost money. Checks safe zones, image resolution, CMYK safety, and dimensions. Built and submitted to the Canva Marketplace; currently under review.

AI-Powered Creation.

A GPU fleet orchestrator for rapid AI content generation. Microservices architecture with FastAPI orchestrator, Redis queue, and RunPod GPU workers generating images in under 1 second.

Autonomous content engine.

An autonomous Instagram content system that analyzes accounts, extracts style patterns, generates brand-aware content at 5 posts/hour, and learns from human feedback via Slack.

See what meetings really cost.

A macOS menu bar app that tracks the live dollar cost of any meeting. Swift 6 + SwiftUI, StoreKit 2 IAP, App Sandbox, zero network. Built end-to-end by a Claude Code app-builder agent from a SPEC.md file, 11 days from scaffold to the Mac App Store.

Smart clipboard transforms.

A macOS menu bar app that detects what you copy, JSON, URLs, hex colors, emails, code, UUIDs, and offers one-click transformations tailored to that content type. Native, fully offline, Keychain-sandboxed.