Inspiration

Most AI app builders fail before they write a single line of code. A non-technical founder types "a booking site for my barbershop," the AI guesses everything else, and the user pays credits to fix those guesses. Reviews of tools like Base44 keep describing the same pain points:

Vague prompts lead to apps nobody asked for
Credits burned on failed generations and debugging
"Done" claims that don't hold up, plus unrequested changes to colours and text
Lock-in, because backend-dependent apps can't leave the platform

Our insight: a weak prompt produces a weak app. Fix the prompt first, then verify the result. That became Blueprint:

Say it once. Build it right. Own it forever.

What it does

Blueprint turns a rough idea into a verified, editable, exportable website:

Prompt Architect interviews you with a few short questions, then writes a detailed, structured prompt covering pages, features, data, users and style. You read it, edit it and approve it. The approved prompt becomes the App Spec, the single source of truth.
Planner splits the Spec into a file-by-file build plan and shows a cost estimate before anything is built.
Builder generates the app from the plan.
Verifier writes and runs tests in a sandbox and shows a pass/fail report, so "done" is evidence, not a claim.
Editor applies later changes as visible diffs with one-click rollback, and never touches locked files.
Export gives you the full app (frontend and backend) as a ZIP that runs with one command.

How we built it

All five agents run on an eligible NVIDIA Nemotron open model through Nebius Token Factory. The sandbox that runs tests and hosts generated sites runs on Nebius AI Cloud.

Generated apps use a deliberately standard stack: React, a simple backend, Postgres and Docker. Because nothing is proprietary, "no lock-in" is real. The App Spec is stored as JSON with Git history, which gives us diffs and rollback almost for free.

To keep generation reliable, we use one fixed template family. The AI customises the template from the Spec instead of inventing an app from scratch.

Two small formulas drive the trust features. The pre-build cost estimate sums token usage across the planned agent calls:

$$ \hat{C} = \sum_{i=1}^{n} \left( t_i^{\text{in}} \cdot p_{\text{in}} + t_i^{\text{out}} \cdot p_{\text{out}} \right) $$

where $t_i^{\text{in}}$ and $t_i^{\text{out}}$ are the input and output tokens of call $i$, and $p_{\text{in}}, p_{\text{out}}$ are the per-token prices. The verifier reports a simple pass rate:

$$ V = \frac{\text{tests passed}}{\text{tests run}} $$

An app is only marked done when $V = 1$.

Challenges we ran into

Unreliable code generation. Letting a model write a full app from nothing was too fragile, so we moved to template customisation.
Keeping the AI in its lane. Early on, edits could change things the user never asked about. Restricting the Editor to files the plan allows, and showing every change as a diff, fixed this.
Scope. Payments, mobile apps and many templates were tempting. We cut them and focused on one demo app type, `, so the demo works end to end.
Honest verification. Tests that only check "the page loads" prove little.

Accomplishments that we're proud of

A working multi-agent pipeline from rough idea to verified, exportable site
A cost estimate shown before building, so there are no surprise bills
Export that genuinely runs anywhere

What we learned

Spec-first beats prompt-and-pray. A structured, user-approved Spec makes every downstream agent more predictable.
Constraints improve reliability. A fixed template plus narrow agent permissions beat open-ended generation.
Trust is a feature. Evidence of working (tests), visible changes (diffs) and predictable costs matter as much as speed.

What's next for BluePrint

More template families beyond booking and client portals
Payments, custom domains and mobile apps
A team tier with shared Specs, roles and an audit log
Predictable subscription plans with caps instead of confusing credits, starting with local service businesses