Mullion
Turns a one-line idea into a reviewable technical blueprint or a finished, working codebase, letting you watch and steer a team of agents plan the system live instead of waiting on a black box.
Role
Full Stack Developer
Team
Solo
- Durable build orchestration on Temporal so a multi-agent build survives a crash mid-run and replays deterministically
- Real sandbox isolation for untrusted generated code: hardened Docker with no network, read-only rootfs, and all capabilities dropped, behind a provider-agnostic interface that E2B slots into
- Combined LLM plus sandbox budgets enforced as a circuit breaker, per run and per org, so cost can never run away
- Streaming the planning phase live over SSE so the architecture diagram and decision log build up in front of the user and stay editable in plain language
- Partial and abandoned builds get the same delivery options as full successes, so a run always leaves the user with something
- Every external service (LLM, sandbox, artifact store, GitHub) has a local or fake driver picked by config, so the whole system runs on a laptop with only Postgres, Docker, and a Temporal dev server
- A role-based agent team (Analyst, Planner, Coder, Tester, Reviewer, DevOps) with a tool-loop build runner, coordinated by a durable state machine
- Ports-and-adapters everywhere: one interface per external concern with a real driver and a fake, so tests and local dev never touch a paid API
- Role-to-model routing kept in the database with ZDR-only providers, and cost recorded per LLM call for replayable spend accounting
- OpenTelemetry traced end to end, including inside Temporal workflows, so every decision in a build is inspectable after the fact
- Record and replay on the LLM layer makes builds reproducible and evals deterministic across system versions
- Visible, steerable planning sits between fully autonomous agents and line-by-line assistive tools without giving up a production engineering bar
Overview
Mullion turns a one-line idea into either a reviewable technical blueprint or a finished, working codebase, and lets you watch and steer the planning as it happens instead of handing an idea to a black box and waiting.
You describe what you want to build. An Analyst agent asks a short, capped round of multiple-choice questions to clear up anything ambiguous. A Planner agent then designs the system live, in front of you: an architecture diagram and a decision log build up in real time, and you can interrupt in plain language at any point ("use Postgres instead", "add rate limiting"). When you confirm the architecture, you pick your exit: take the full set of design documents to your own team, or hand it to a pipeline of Coder, Tester, Reviewer, and DevOps agents that implements, tests, and reviews the whole thing on its own.
5
Build phases, verified
2
Delivery exits
6
Agent roles
ZDR
Providers only
The gap it fills: fully autonomous coding agents work but are opaque, and assistive tools keep you in the loop for every line, which does not scale to "build me a whole thing." Mullion sits between them. The planning is visible and steerable like working with a person, and the engineering underneath is held to a production bar: durable execution that survives a crash, real sandbox isolation, hard cost limits, and a replayable trace of every decision.
How It Works
- 1
Idea
You describe what you want to build, in a sentence or two.
- 2
Clarify
An Analyst agent asks capped rounds of multiple-choice questions to fill in what is ambiguous. No open-ended interrogation.
- 3
Plan, live
A Planner agent builds the architecture in front of you: a React Flow diagram and a decision log stream in over SSE, editable by just saying what to change.
- 4
Confirm
You explicitly lock in the architecture. A consistency check runs before the freeze.
- 5
Choose a path
Take the spec documents and build it yourself, or hand it to the automated build pipeline.
- 6
Build and deliver
Coder, Tester, Reviewer, and DevOps agents implement, test, and review unattended, pulling you in only for a narrow decision if truly stuck. You get a downloadable archive and/or a push to your own GitHub repo.
Key Features
Visible, steerable planning
The architecture is built in front of you, not behind a spinner. A live diagram plus decision log, redirectable mid-thought in plain language, is the core experience.
Two honest exits
Walk away with a full set of design documents at no cost beyond the planning conversation, or let the pipeline build it. Automated building is a choice, not the only path.
Durable orchestration
The build state machine runs on Temporal, so a multi-agent build survives a crash mid-run and replays deterministically rather than losing all progress.
Hardened sandbox
Generated code runs in a Docker sandbox with no network, read-only rootfs, and all capabilities dropped. E2B fits behind the same provider-agnostic interface.
Cost circuit breaker
Combined LLM and sandbox budgets are enforced per run and per org. When a run hits its ceiling it trips, so spend can never run away unattended.
Role-routed LLM access
OpenRouter only, with role-to-model routing kept in the database, ZDR-only providers, and cost recorded per call. Record and replay makes builds reproducible.
Delivery for any outcome
Partial and abandoned builds get the same delivery options as full successes: a zip archive or a GitHub repo push, so a run always leaves you with something.
Runs on a laptop
Every external service has a local or fake driver picked by config, so the whole system runs with only Postgres, Docker, and a Temporal dev server. Real credentials are optional swaps.
Architecture
A Turborepo + pnpm monorepo split by concern, each package with a real driver and a fake:
The automated build is a long, multi-step, agent-driven process that must survive process crashes and be replayable for debugging and evals. Temporal models this as a deterministic workflow: the build state machine resumes exactly where it left off rather than restarting from zero.
The system runs code an LLM just wrote. The sandbox drops all Linux capabilities, mounts a read-only rootfs, and removes network access by default, all behind one interface so the isolation guarantee does not depend on which provider (local Docker or E2B) is active.
Ports and adapters are not decoration here: every paid or external dependency ships a fake selected by config. The full planning-to-delivery loop is exercisable on a laptop, and CI never touches a real API key.
Outcome
Mullion demonstrates a production-grade multi-agent build system, not a prompt-chaining demo: a visible, editable planning phase streamed live to the user, a durable Temporal state machine that survives crashes and replays, real sandbox isolation for untrusted generated code, hard per-run and per-org cost limits, and end-to-end OpenTelemetry tracing. v1 is feature-complete across all five build phases with a security review at the end of each, verified against local and mock drivers.