Mullion

Turns a one-line idea into a reviewable technical blueprint or a working codebase. You watch a team of agents plan the system live and steer them as they go.

Status: In progress
Role: Full Stack Developer
Team: Solo

The problem

Autonomous coding agents are opaque, while assistive tools keep you involved for every line of a whole-system build.

Who it is for

Anyone who wants to turn a one-line idea into a reviewable technical blueprint or a finished codebase.

What I built

A planning-first build system. An Analyst agent asks a short, capped round of multiple-choice questions. A Planner agent then designs the system live, with an architecture diagram and decision log you can redirect in plain language. Once you confirm the architecture, you either take the design documents or hand it to Coder, Tester, Reviewer, and DevOps agents that implement, test, and review it across five build phases. This project is in progress.

Built with

Frontend: Next.js 16
React 19
React Flow
TanStack Query
Backend: Hono
Node.js
Better Auth
Drizzle
Zod
Orchestration: Temporal
OpenRouter
Sandboxing: Docker
E2B
Data & Storage: Neon Postgres
AWS S3
Observability: OpenTelemetry
Infra: Turborepo
pnpm workspaces

Key decision

Make planning visible and steerable before implementation, then let users choose between a reviewable blueprint and an automated build pipeline.

Proof

v1 is feature-complete across all five build phases, with a security review at the end of each and verification against local and mock drivers.

In detail

Build phases, verified: 5
Delivery exits: 2
Agent roles: 6
Providers only: ZDR

How it works

Idea
You describe what you want to build, in a sentence or two.
Clarify
An Analyst agent asks capped rounds of multiple-choice questions to fill in what is ambiguous. No open-ended interrogation.
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.
Confirm
You explicitly lock in the architecture. A consistency check runs before the freeze.
Choose a path
Take the spec documents and build it yourself, or hand it to the automated build pipeline.
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, with a live diagram and decision log you can redirect mid-thought in plain language. This is the core of the product.

Two 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 optional.

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 and pnpm monorepo split by concern, with a real driver and a fake for each external dependency:

apps/web              Next.js: intake, MCQ, live planning canvas, build view, delivery
apps/api              Hono HTTP API + Temporal build-worker process
packages/agents       Agent roles + the tool-loop build runner
packages/orchestrator Temporal workflow + activities: the durable build state machine
packages/llm          Single OpenRouter integration: role routing, ZDR, cost, record/replay
packages/sandbox      Provider-agnostic sandbox: hardened Docker driver, E2B stub
packages/artifacts    Durable store for build output (local disk or S3)
packages/delivery     Zip archive + GitHub repo push
packages/db           Drizzle schema, migrations, pooled client
packages/schemas      Shared Zod contracts: API, agents, build spec
packages/otel         Shared OpenTelemetry setup + span helpers
packages/config       Env schema validated at boot

Decision

Durable execution over a job queue

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.

Tradeoff

Untrusted code is the threat model

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.

Note

Local-first by construction

Every paid or external dependency ships a fake that config can select. The full planning-to-delivery loop runs on a laptop, and CI never touches a real API key.

Outcome

Mullion is a multi-agent build system with 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.

Challenges

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

What I learned

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

Have a role in mind?

Send me a message on X with the role and a link to the posting. My resume has the rest.

Send me a message Book a call

Building a product instead? See how I work with founders.