BuildLabs
BuildLabs turns a conversation into a fully delivered software. A customer describes the website or web app they want, out loud, then an orchestrator listens understands the requirements to be built and collects the exact payment the customer agreed to through Stripe. From there, it dispatches several build agents in parallel, and each one builds a working version of the application inside its own isolated sandbox.
This system hands the customer a proven, production-hosted result from a single phone call, entirely on its own, with no human ever signing off along the way. Alongside the finished product, every project keeps an honest record of exactly what got verified, and how.
Key technical architecture and components
An orchestrator runs a loop: gather context, take one bounded action, verify, then persist. It repeats this over transcripts, replies, webhooks, and builder events, backed by an encrypted aggregate, an immutable event log, a verified webhook inbox, and stable idempotency keys, so the whole system can recover cleanly from a crash.
Each build runs on a four-slot runtime. Every assignment gets one Fireworks agent working inside one isolated builder sandbox, and once that build is frozen, an independent proof stage takes over. The controller content-attests the frozen source, then hydrates two fresh verifier sandboxes: a command verifier that runs the host build, the tests, and a scan for forbidden claims, and an untouched delivery verifier that builds the Docker image and serves the preview. Builder output can never seed the shipped artifact directly.
At the center sits an evidence-first proof gate. A pure function called decideProof takes in the contract, the revision hash, and the receipts, then re-derives a pass or fail outcome using only receipts that match the frozen revision. Every hard requirement needs a passing deterministic command or a rendered-HTTP verifier standing behind it, and any business claim without evidence blocks the release. That rendered evidence always comes from Chromium-computed visible text, never from raw HTML source.
A transactional outbox keeps things honest at the finish line. Only a candidate that passes and gets proven emits a candidate.proven event. From there, the orchestrator ranks the proven candidates deterministically, deploys the winner to Fly.io, and emails the customer their production URL, all while the production deploy token stays completely clear of the sandbox.
Two separate surfaces handle authorization. An operator studio gives the team raw live panes, evidence, and the power to cancel a run. A project-scoped, passwordless customer dashboard shows a sanitized, clearly labeled "UNVERIFIED WIP" view, frozen previews once they're proven, and a way for the customer to steer the build. Watching a build in progress is always kept separate from proof.
The sponsor tools, and how we used them
Six sponsor tools sit at the core of BuildLabs, and each one is load-bearing: pull any single one out, and a necessary part of the product stops working.
Daytona hosts the sandboxes. Each slot gets one isolated builder plus two controller-created verifiers, all hydrated from a single content-attested export. Once the delivery build checks pass, we switch on Daytona's persisted networkBlockAll outbound firewall before rendering anything, so only the sealed delivery verifier can ever become the accepted snapshot or preview. A pinned Docker-in-Docker and Chromium setup runs Playwright through a bounded, same-origin, frozen-DOM crawl of the site's routes, producing tiled, byte-exact, differential proof of the visible text. Every sandbox carries labels for run, project, candidate, and role, so it shows up cleanly in OpenTelemetry.
Fireworks AI powers every reasoning and code-generation model in the system: the voice agent's brain, the orchestration agent, the build agents, and the RFT-trained Patch Model. It runs interleaved reasoning with project-isolated prompt caching. We default to Minimax m3 for the different agents. The raw reasoning itself is always kept out of storage.
Braintrust traces every decision, every tool call, and every revision. It scores each candidate and works as the automated evaluation gate, and Fireworks' token, cache, and latency numbers feed straight in as native metrics. Braintrust also decides whether a Patch Model checkpoint earns promotion, comparing the trained checkpoint against the base model on a held-out set with HMAC-attested bundles. A checkpoint only earns the eligible-for-manual-promotion status once it shows a measured improvement. The traces themselves stay content-free, holding no reasoning and no transcripts.
ElevenLabs supplies the voice: the conversational AI that runs the intake call, and the embedded voice used for spoken operations inside the studio. The backend exposes authenticated, bounded webhook tools, gated by provider-marked system__conversation_id and system__conversation_history values plus a short-lived, controller-signed capability. A server-only WebRTC token endpoint keeps the API key safely away from the browser. The reasoning underneath is still Fireworks, end to end.
CopilotKit builds the role-separated operator studio and customer workspace: contract cards, candidate comparison, live diffs, a component tree, steering controls, and four live panes. All of it streams over the official AG-UI protocol, with 256-event paged durable replay, cursor continuation, and keepalives.
CodeRabbit runs as the official headless CLI, reviewing every frozen project against a deterministic, controller-authored Acceptance-Contract policy passed in. Its findings feed the agent's bounded, in-loop repair rounds. Any unsupported business claim counts as critical, and a critical finding, or even a missing policy digest, blocks the candidate from being proven.
Supporting infrastructure
A few more pieces round things out, sitting alongside the sponsor tools rather than among them. Fly.io handles the orchestrator-owned production deploys: Docker-native, unattended, token-based, with scale-to-zero built in. Resend carries the correlated customer email thread. And Stripe Checkout handles the mandatory, version-bound payment, verified through signed webhooks before any build work begins.
Log in or sign up for Devpost to join the conversation.