We run the agent graph that builds the software.
You send a brief: the spec, the constraints, and the proof the work has to pass. It becomes a graph of tasks, and each node goes to its own agent session with no memory of the others. Hooks stop bad calls mid-turn, gates run before anything merges, and a judge reads the diff with no power to approve it.
Brief in Verified commit out Every decision written to the trace
Isolates. Gates. Refuses. Records.
Work
Two apps and two channels, each built through the same graph the rest of this page describes.
-
Tahona
TestFlightA cabinet and tasting log for agave spirits: what you own, what you poured, where it came from.
A native SwiftUI rewrite, shipped through the graph. Bugs arrive as GitHub issues and are fixed overnight; every fix passes the gate before it is pushed.
-
Croze
In developmentA cocktail app built on pairs. Every drink has a second drink and a one-line reason; turn on the light and the page reveals it.
Designed as 34 boards before any code. A screen is accepted only when its screenshot matches its board.
-
FM Daydream
On YouTubeOriginal indie playlists written for a film: a roster of invented artists, their songs, a cover and a scheduled upload.
A stage machine runs it unattended: analyze, write, generate, order, render, schedule. A rerun is a no-op, never a second upload.
-
Compute Fantasy Podcast
Weekly on YouTubeA weekly radio show about a twelve-team fantasy league, with four hosts who cover it like a network broadcast.
League data becomes a beat sheet; one human edit, then script, voices, cover, video and upload.
The music and the voices are generated; both channels carry YouTube’s AI label.
How we build
Seven moves in a loop. Each one is either code that runs or a model session that starts clean.
-
The spec becomes a graph.
Nodes are tasks and edges are the contracts between them. A task can start only once the thing it depends on exists. Parallelism falls out of the graph. Nobody schedules it.
-
Every node gets a fresh worker.
Each session gets one brief and no history. Context is still clean forty steps in. A retry starts over, so it cannot inherit the reasoning that failed the first time.
-
Hooks refuse before the model finishes the sentence.
Sessions cannot spawn subagents or leave background jobs running, and no turn ends on a dirty tree. The refusal comes back from the process running the session, before the tool call completes, so there is no instruction left for the model to ignore.
-
Code gates the commit. Then a judge.
Build and tests run first, then a check that the diff touched only the files the brief allowed, then whatever that brief named as its own proof. Only when all of it passes does the judge read the diff. The judge's only verdict is no. Green means the checks passed, never that a model approved the work.
-
Failure goes to triage first.
Triage reads the node's history and picks one move: retry, resume, rewrite the brief, split the task, or escalate. A budget can stop the run outright. Any step that cannot be undone writes a receipt before it acts, so a retry can never double it.
-
Everything lands on the trace.
An append-only log of every spawn, gate, verdict and decision, each with its reason. Progress comes from git, not from status updates.
-
You get paged for decisions. Only decisions.
An escalation arrives as a single question with the options already worked out. Your answers move the threshold. Overrule a few calls and the system starts asking earlier. Agree with a few and it asks less often.
What's different
Memory is a file on disk.
Our workers have none of their own. Everything that has to survive a session gets written down in one place, and you can open it.
The judge can only say no.
A block sends the node back to triage with its reason on the trace. Nothing in the system turns that into an approval.
Nothing irreversible runs twice.
Publishing, paying and uploading each write a receipt before they act. If the receipt is there, the work is already done and the retry stops.
Send the brief. We send back verified commits.
Good first briefs describe a pipeline nobody should have to watch, a codebase with more work queued than attention to give it, or the thing you keep pushing to next quarter.