The thing I keep reaching for
Every frontier model is the best at something. Once you have had the best tool for a task, you have to have it every time for that task until something better arrives. Claude for architecture. GPT for certain prose. Gemini for multimodal reasoning. The problem is not which model to use. The problem is that the answer changes per task, per day, and you need all of them running at once.
GBuild is the build environment I started writing to solve that. One macOS desktop app, one calm interface, a whole fleet of coding agents orchestrated across an entire organization. Claude Code, OpenClaw, Hermes, and any CLI-based agent tomorrow. Instead of switching windows, you switch models, and the system handles the rest.
The why, in long form: "Building What I Keep Reaching For"
6,308
Commits in 81 Days
275
Notarized Releases Shipped
916
Sidecar RPC Methods
5
First-Party Agent Drivers
One shell, decided by evidence
GBuild spent its first months shipping two parallel UIs: the calm Lattice shell and a power-user portal called the Batcave. Then a full-stack audit showed the second shell was pure drag, and it was deleted in a single decision. The closed set of shell surfaces is now three: the Lattice cockpit, the menu-bar ambient presence, and mobile. Retiring your own architecture the moment the evidence says so is the feature.
Lattice
The one shell
- Browser-like tabs with an omnibar that accepts a prompt or a URL
- Jarvis-style G voice drawer: say "G, open three Claude Code sessions on PrayerMap" and get spoken status back
- Power surfaces ship as native Apps inside it: Mission Control, AI Video Studio, ThingStore, Connectors
The 26,000-line deletion
ADR-014, June 2026
- A full-stack audit found the legacy v3 shell mounted hidden behind every session, holding live subscriptions and memory
- The confirm modal for destructive voice intents lived only in v3, so those intents silently no-oped in the shipping shell
- 56 files and roughly 26,200 lines deleted in one decision; the app entry point shrank from 873 lines to 54
What ships inside the shell
The power surfaces did not disappear with the second shell; they returned as native Apps inside Lattice, each registered through the same manifest system. The sidebar is customizable per operator, and the catalog behind it is wide. Grouped by what they let you do:
Build
Websites · iOS & Android Apps · Slate · Rapid Studio
Dedicated surfaces for shipping real artifacts: website and mobile-app build flows, a creatable spatial canvas (the Slate), and a rapid prototyping studio. This is the "Build anything" tagline as literal UI.
Create
AI Video Studio · Images · Videos · My Socials · Ship Content · Audience Builder
A full creator pipeline: local-first multi-track recording with transcript-driven AI editing, media generation, and the drafting-to-audience path, all with review-before-publish discipline.
Know
2nd Brain · Files · .md Heaven · Messages
A fully local RAG memory (Qwen3 embeddings on-device), file and document surfaces, and communications, so agents answer from your actual context without your data leaving the machine.
Run
Mission Control · Brain Panel · Concierge · Co-work · Plan · Scheduled · Maps · Calendar · Contacts
The operations layer: org dashboards in-shell, a menu-bar ambient surface with a talk-to-G entry point, a daily concierge, scheduled agent runs, and a voice-driven cinematic map.
Extend
ThingMaker · ThingStore · Connectors
An interview-driven creator (four interviewer personas) that builds installable Things, a store that verifies every install with SHA-256 digests and Ed25519 signatures, and full MCP lifecycle management.
Guard
Global halt-switch · Sandbox · Redaction
One observable safe-stop wired through six chokepoints across GBuild’s own agent fleet, drilled live before it merged, plus sandboxed MCP servers and token redaction on every PTY stream. Autonomy ships with brakes.
Electron + Rust under the hood
The desktop shell is Electron 42 with a Rust sidecar (codename mother-sidecar, 810 source files, ~290K lines) communicating over JSON-RPC 2.0 on NDJSON stdio, with 916 registered methods across 154 namespaces. The renderer handles the UI. Electron main handles windowing, lifecycle, and IPC routing. Rust handles everything that needs to be fast or long-lived: process management, file watching, crypto, and the agent driver layer.
Renderer (Vite + React) │ IPC ▼ Electron Main (windowing, lifecycle) │ JSON-RPC 2.0 / NDJSON stdio ▼ mother-sidecar (Rust) ├─ Agent Drivers (Claude Code, OpenClaw, Hermes, Codex, shell + BYOA) ├─ portable-pty (wezterm crate family) ├─ G-and-Hats Router (35 hats / 34 SOUL personas, T0–T3 tiers) ├─ macOS Keychain (secrets) └─ Audit Logger (append-only JSONL, daily rotation)
Agent drivers are pluggable. Today that means 5 first-party drivers (Claude Code, OpenClaw with its gateway and remote variants, Hermes, Codex, and a plain shell), plus dynamic bring-your-own-agent registration, each sandboxed. Every driver gets a portable-pty terminal via the wezterm crate family, so every agent session is a real PTY you can see, scroll, and interact with, and every PTY has a guaranteed destroy path.
11-Agent Review Fleet
Orchestrator
director
Acceptance Reviewer
gate
Code Reviewer
code
Security Reviewer
security
Tech Lead
architecture
Health Monitor
watcher
Test Generator
test
Code Simplifier
refactor
Rust Sidecar Specialist
rust
Maps Navigator
spatial
Lane Verifier
verify
The read-only review fleet works beside 35 Hermes specialist hats (34 SOUL persona files) routed by the G-and-Hats layer across latency tiers T0–T3.
Build produces a signed, notarized DMG (3.76 GB) and a lean auto-update zip (0.56 GB) via Vite + electron-builder. Heavy ML resources are de-bundled to R2 and rehydrated at runtime so updates stay under Squirrel's size cliff. 275 tagged releases have shipped through this pipeline, and every auto-update hop is verified N→N+1 on a clean machine before release.
Voice-first
The voice pipeline is not an afterthought bolted onto a text UI. It is a first-class interaction surface built into the Lattice shell from day one.
Example interaction
"G, open three Claude Code sessions on PrayerMap."
G acknowledges vocally, spins up three PTY sessions targeting the PrayerMap workspace, and reports status via speech as each agent comes online.
Pipeline
- STT ... Lightning-Whisper-MLX (distil-small.en) on-device, ~0.18s warm; whisper.cpp fallback
- TTS ... Kokoro (sherpa-onnx) on-device; macOS say and OpenAI TTS fallbacks
- Turn detection ... silence-gated with configurable thresholds
- Realtime path ... Gemini Live by default, OpenAI Realtime fallback
- Cost ledger ... per-session tracking across all voice and LLM usage
Knowledge that compounds
An AI build system that forgets everything between sessions is just a fancy terminal multiplexer. GBuild includes a RAG system designed to make the agents smarter over time, not just faster.
Local vectors, no cloud
Qwen3-Embedding-0.6B + Qwen3-Reranker-0.6B run in-process on Apple-Silicon Metal via candle: no Python, no cloud round-trip. Per-project SQLite + sqlite-vec store; one embedder serves retrieval, dedupe, the personal index, and the vault.
Obsidian + Notion sync
Bidirectional Obsidian sync (the vault is the shared state surface). Notion sync with OAuth, conflict resolution, redaction, and rate limiting.
GBuild owns the full MCP lifecycle: a curated 7-server starter pack, a federated catalog with an Integrations panel, PKCE OAuth, sandbox-exec isolation, Ed25519-signed bundles, and per-spawn config injection. GitHub integration for repo context. macOS Keychain for secrets, with dual-stack redaction on every agent-facing log path. Structured logging spans all three layers (renderer, Electron main, Rust sidecar), with append-only JSONL audit logs rotating daily.
Shipping is a subsystem
275 notarized releases in 81 days means the release pipeline is production software in its own right. One script drives version bump, signed and notarized universal build, DMG stapling, R2 distribution, sourcemap scrub and upload, and the git tag. A fresh-machine landing gate installs every release on a clean test box before it ships; the gate has blocked a release for real, which is the point.
The auto-update path is hardened against nine documented production incidents, each one encoded as an invariant in the updater rather than a memory in a postmortem. Heavy ML resources are de-bundled out of the app to R2 and rehydrated at runtime, keeping the update package (0.56 GB, against a 3.76 GB full DMG) under Squirrel's size cliff. No updater change is done until a real version-to-version hop is verified on a clean machine. Static checks cannot test an apply path; only the hop can.
The other half runs at the edge
The desktop app is half the system. Behind it sits GBuild Cloud: a 14-Worker (in repo) Cloudflare service mesh behind one API gateway, connected by zero-hop Service Bindings with the workers.dev bypass disabled as a security control. Identity is built from primitives, passwordless magic links, opaque bearer tokens stored only as SHA-256 hashes, 4-provider OAuth2 with hand-rolled PKCE, a 16-connector token vault with AES-GCM encryption at rest, and dual-token Supabase JWT minting so mobile clients get RLS-scoped Realtime. No auth SDKs anywhere on the path.
The same mesh carries the money and the safety rails. A key-custody LLM proxy fronts Anthropic, OpenAI, Gemini, and xAI so provider keys never reach a client, metering one usage event per response through a Cloudflare Queue into Postgres and enforcing tier-aware daily dollar ceilings at the request path. A telephony hub brokers SMS and voice over Telnyx behind Ed25519-verified webhooks with a Durable Object WebSocket hub per account. And an autonomy engine evaluates ops playbooks on a cron, governed by off-switches, cooldowns, and circuit breakers, writing an append-only audit record, while a heartbeat monitor alerts on the absence of signals, because a silent fleet is the failure mode that matters.
Instruments before claims
A system that runs 5 kinds of agents needs to know what they actually did. Every sidecar panic writes a redacted, structured crash record, and a companion generator turns each crash into a plain-English investigation playbook with the app version, recent commits, and changed files already attached. A cognition recorder spans all three layers, and a full-fidelity agent tool-call sideband is built and wired, currently dark by default until measurement runs need it.
The eval work is where the honesty discipline earns its keep. The Foundry, GBuild's on-device model line, trains a small grounding verifier that checks whether an answer is actually supported by the tool output behind it. The model scored 97.5% on its own synthetic holdout and 62% on a 95-row human-labeled gold set: a 35-point overfit that only hand labeling caught. That model is not in the product, because the promotion gates it has to pass are code, not judgment calls. Publishing the failure is the credential; the gates are the engineering.
Two subsystems earned their own case studies: ThingStore (supply-chain security) and The Foundry (the on-device model line).
A recording studio, because agents make content too
GBuild ships a full AI Video Studio as one of its apps. Recording is local-first: camera, mic, and screen each write to disk as separate tracks through the Rust sidecar, with a built-in teleprompter and solo or multi-guest sessions (up to 3 remote guests over LiveKit, each guest's track pulled individually so nothing depends on a lossy composite). Presets run from 4K down to audio-only, and every session lands as a structured artifact, not just a file.
The editing side is transcript-driven and runs on the same sidecar: silence and filler-word removal, clarity cuts, retake detection, AI clips and chapters, styled captions with translation, eye-contact correction, audio cleanup, and waveform scrubbing, all composed through an ffmpeg pipeline with export to NLE timelines when a human editor takes over. It is the same architecture as the rest of GBuild: the UI stays a thin view, the sidecar owns the media, and every heavy job goes through a queue that can be observed and cancelled.
Meet G
GBuild's mascot is a friendly chibi AI companion: a dark spherical head with a rainbow-gradient G-shaped arc ring wrapping around it, expressive arc eyes, and a small jaunty rainbow flag on top. G lives both as 2D brand art and as a real-time 3D model with custom GLSL shaders.
Mascot lockup // Build, Chat, Code, Deploy, Analyze
7-State Behavioral Machine
Each state drives breathing rhythm, pointer tracking, blinking cadence, arm poses, and a particle field with per-state GLSL shader modes. Six gestures: wave, thumbs-up, point, shrug, celebrate, think.
Rainbow Brand Palette
Signature 5-stop gradient at 35deg. Neutrals: bg #0B0F1A, surface #111827, fg #E5E7EB. Design system name: "midnight-glass."
Where it's headed
The marketing site is live now at gbuild.app (Next.js 16 + React Three Fiber + GSAP + a Supabase-backed waitlist). You can meet G in 3D at gbuild.app/play.
The desktop app (internal codename "Mother") is in active private development: Electron 42 + a Rust sidecar, 6,308 commits and 275 notarized releases in its first 81 days, every one shipped through an auto-update pipeline that is hop-verified on a clean machine. It is held private until the core loop works. That is a deliberate choice, not a delay. The public macOS release is ahead. The waitlist is open now.
Values shown on the landing manifesto ticker: calm by design, anti-bullying, anti-hate, inclusive by default, made for everyone. The UI is "video-game alive" (Rive + Lottie + Framer Motion) with a reduced-motion toggle for accessibility.
Build anything. Smarter. // In progress . -JJ