Crucible — Product Overview

The Big Idea

A software company with almost no one inside.

Crucible is an autonomous product factory. You hand it a one-paragraph idea; it carries that idea through research, thesis, PRD, user stories, architecture, design, code, QA, documentation, and marketing strategy — with frontier AI models doing the work and a human touching only a handful of decisions. It is the working proof of the Near Zero Labs thesis, measured by the number that matters: human minutes per product.

12+

pipeline phases, idea → shipped product → campaign plan

3×

competing frontier models per phase, one per AI family

human gates — each with a dial that earns its way toward autonomy

~150 min

human attention per product, and trending down

How it works

01 · TOURNAMENT

Nothing gets one shot.

At every phase, three frontier models — one each from OpenAI, Anthropic, and Google — independently produce candidates. Quality comes from competition, not from trusting any single model's first draft.

02 · ADVERSARIES

Everything gets attacked.

Reasoning models are paid to refute: kill the thesis, break the pricing, find the compliance landmine. An objection that changes the final document is recorded — so every surviving claim has a paper trail.

03 · BLIND JUDGES

Votes, not vibes.

A panel of three judges — drawn from AI families that didn't write the candidates — scores blinded copies against a versioned rubric and votes. A synthesis model merges the winner with the losers' best ideas.

04 · HUMAN GATES

Minutes, not meetings.

The human reviews the finished artifact inside the product — annotated with every objection and vote — and approves, revises, or re-runs. The clock only runs while the review is open. That's the entire human job.

Why it's different

Provenance. Every model call, score, vote, dollar, and human decision lands in an append-only run ledger. When Crucible says "this pricing survived adversarial review 3–0," you can open the ledger and watch it happen.

It learns which minds to hire. The model roster is maintained by evidence: tournament win rates, adversary kill rates, judge agreement with human decisions. New models audition in a fourth seat; underperformers get cut. Marketing experts (as doctrine skills) are graded the same way — eventually against real campaign results.

It performs. Showcase mode replays any completed run for an audience — the bracket filling in, judges splitting, gates passing, the human-minutes counter barely moving. A room can watch how a product was born. That demo is Near Zero Labs' best sales asset.

Watch the Mission Control prototype → Read the PRD

The Pipeline

Every phase is the same machine with different settings.

Generate candidates in parallel → adversarial review → blinded judge panel → synthesis → gate. The pipeline below is that loop, twelve times, with the artifact of each phase becoming the input of the next. Everything lives as files in git; any phase can be re-run, swapped, or audited without touching the others.

Intake

Happens in the web app: describe the product, marketplace, or problem in free text and upload any documents or research you already have. Crucible prompts with follow-up questions — none required. Say "Let's go" at any point and the intake agent compiles the brief from whatever you provided.

→ brief.md + artifacts/intake/*

Research

Three to four web-enabled agents, each with a different lens — industry structure, competitor features, customer-feedback mining, pricing landscape.

→ research.md

Thesis HUMAN GATE · GO/NO-GO

Full tournament. Each candidate is a product thesis: opportunity, wedge, positioning, pricing. One adversary carries a compliance lens. The cheapest place in the whole pipeline to kill a bad idea.

→ thesis-FINAL.md

PRD

Tournament over full product requirements documents.

→ prd-FINAL.md

User stories

INVEST-compliant stories with Given/When/Then acceptance criteria and stable IDs that trace all the way to commits and screenshots.

→ stories-FINAL.md

Architecture HUMAN GATE

Tools, structure, APIs, and build / buy / integrate decisions.

→ architecture-FINAL.md

Design HUMAN GATE

Two to three distinct directions as clickable HTML mockups — judged by eyes, not essays.

→ direction picked

Test plan

Acceptance criteria become a test-suite spec before any code exists — so builders get an objective finish line they didn't write themselves.

→ test-plan-FINAL.md

Scaffold & contracts

Repo, CI, environments, seed data — and the frozen interface contracts (routes, schema, shared types) that make parallel building mergeable.

→ contracts frozen

Build swarm

Parallel Claude Code agents in isolated worktrees. Per task: tests pass → Codex adversarial review → merge. Then an integration pass hunts the seams.

→ merged main, suite green

Demo & QA

Demo account seeded with realistic data; scripted user journeys on desktop and mobile; screenshots of every screen and state. Failures loop back as fix tasks.

→ verified build

Docs & portal HUMAN GATE · SHIP

Per-feature docs, a visual user guide, and a review portal: screens gallery, story-coverage map, demo credentials, what-to-test checklist.

→ review portal live

Campaign portfolio HUMAN GATE

The marketing board deliberates (see the Marketing Board tab) and delivers 2–3 campaign briefs with budget split and KPIs. Execution tools plug in later.

→ campaign briefs

The rejection path is explicit. If judges reject every candidate or a gate sends work back: regenerate with the feedback injected, maximum two rounds, then escalate to the human. No silent loops, no silent passes.

Product Requirements · v1.0 · 2026-08-30

Crucible PRD

The full requirements document, kept current as decisions land. The repo copy (PRD.md) is the source of truth.

1 · Overview & problem

Crucible takes a one-paragraph product idea through research, thesis, PRD, stories, architecture, design, code, QA, docs, and marketing strategy with frontier models doing the work and a human at a handful of gates. One model/one shot produces mediocre strategy; competition plus adversarial pressure produces quality — but orchestrating that by hand is impractical, and without a ledger there's no provenance to trust.

2 · Goals & success metrics

Human minutes per product — headline metric. Clock runs only from "Open review" to decision. Target: down run over run.
Cost per run — actual dollars from OpenRouter's generation endpoint plus build-agent costs, live.
Gate agreement — % of panel verdicts the human would have made; the evidence for dialing gates toward autonomy.
Repeatability — a new project starts from the template repo in minutes.

Non-goals (v1)

Marketing campaign execution (briefs are the socket; tools plug in later)
Multi-tenant SaaS for outside customers
Native mobile Mission Control

3 · Core concepts

Term	Meaning
Tournament	3 generators (one per AI family) → adversarial review → blinded 3-judge panel → synthesis into `*-FINAL.md`
Adversaries	Reasoning models prompted to refute, each with a distinct lens (kill-the-thesis; compliance/feasibility)
Judges	From families not in the generator pool; score blinded candidates against a versioned rubric; vote
Gate	Human decision point with an autonomy dial: approve → veto-window → autonomous
Ledger	Append-only `ledger.jsonl` in git + mirrored Supabase events; source of truth for everything
Roster	Model lineup in `models.yaml`, version-pinned, maintained by the roster-scout skill on ledger evidence

4 · Human gates & the autonomy dial

Each gate has three positions — approve (halt for human), veto window (proceed in N hours unless objected), autonomous (unanimous panel passes) — and every gate starts at approve. Promotions are earned with ledger evidence (panel agreement with past human decisions). The thesis go/no-go stays human indefinitely.

Gate review UX: the artifact opens inside Mission Control as a typeset document — never a raw file. Judge and adversary commentary is anchored to the sections it concerns. The human attaches notes to any section and chooses: Approve · Revise synthesis with notes · Re-run tournament (notes prepended to every generator prompt) · Re-run an upstream phase (new knowledge changed the inputs). Revisions return with only changed sections highlighted. Every note and decision is a ledger event.

Human-minutes rule: the clock runs from the "Open review" click to the decision (or drawer close). Idle gates cost nothing. Displayed per run; averaged per product on the factory floor.

5 · Model roster & scout

models.yaml defines named pools: generator_frontier, workhorse, adversary_reasoning, judge_pool, research_online, synthesizer. Exact version-pinned OpenRouter IDs — never "auto".
Diversity rules: generators one-per-family; judge families ≠ generator families; candidates blinded before judging.
Roster-scout skill runs at every run start: queries OpenRouter's models API for releases/prices/deprecations, reads cumulative roster-history/, proposes the lineup, and fills one audition slot — a newcomer earns a permanent seat at 2 tournament wins or exits at 0-for-4.
Cross-project learning: win rates, adversary kill rates (objection-to-change %), judge human-agreement %, cost-per-win.

6 · Mission Control

New Run (intake): free-text product description, drag-and-drop upload of existing docs/research (saved to artifacts/intake/), optional AI follow-up questions — none required — and a "Let's go" action that creates the project repo, compiles brief.md, and starts research.
Factory floor: human min/product as the headline stat; active runs, waiting gates, 30-day spend, roster; run cards with mini phase tracks.
Run view: 12-phase track with gate diamonds; live tournament bracket; cost/token/human-time meters; per-model spend; streaming ledger feed; build-swarm task tiles.
Gate review drawer per §4, with the human-minutes session clock.
Model provenance cards: hover any model → provider/lineage/release + context/pricing (OpenRouter API) + live spend + the model's factory record from the ledger.
Showcase mode: same UI, pointed at a completed run's events with a playback clock — replay how a product was born, for an audience. The dashboard is a pure reader; if it dies mid-run the pipeline doesn't notice.

7 · Technical architecture

Layer	Choice
Factory repo	`crucible`: Node orchestrator CLI, phase skills (genericized wh-* set), versioned rubrics/prompts, `models.yaml`, `roster-history/`, project template
Project repos	One per product, from the template; artifacts + ledger committed per phase
Doc phases	OpenRouter (one API key per project for billing separation; costs from the generation endpoint are actuals)
Build phase	Claude Code headless builders × Codex reviewer, git worktrees, test suite as the objective judge
Human dev sessions	Coding runs in Claude Code, not the web app: every project repo ships with a factory-written `CLAUDE.md` (contracts, story IDs, ledger rules), so `cd project && claude` is the whole handoff; Mission Control stays the observation/gate surface
Events	Dual-write: `ledger.jsonl` (git) + Supabase (Realtime feed); Slack ping on gate open; gate decisions written back and polled
Dashboard	Vercel at `crucible.nearzerolabs.com`, Supabase Realtime, access-gated

8 · Build order

Stage runner + ledger + models.yaml + gate config ✓ done 8/30
First live run (PermitPilot, phases 00–05) to tune rubrics ⏳ in progress
crucible resume — orchestrator resumable from the ledger alone; must survive kill -9. Precondition for the swarm and multi-day detached runs
Machine-extract layer — every FINAL ships a FINAL.json (decisions/constraints/non-goals); downstream agents consume the JSON by default
Event schema + Supabase + dual-write → Mission Control v1 (incl. web intake)
Build swarm, spec'd around the session loop: respawn-on-death per worktree; feature_list.json flipped only by the orchestrator on green tests; handoff notes record failed approaches; launch gated on a proven e2e harness; definition_of_done.json frozen at the test-plan gate; completion-challenge on every done-claim; serial merges with smoke tests
Demo/QA + docs/portal
Roster-scout + roster-history rollups
Marketing board + Phase 12
Showcase mode

9 · Risks & open questions

Judge calibration drift — versioned rubrics; quarterly audit of tournaments vs. human picks.
Swarm merge conflicts — frozen contracts; integration pass hunts seams.
Model deprecations mid-run — scout checks at run start; pinned IDs fail loudly.
Trademark — preliminary research only; attorney clearance before public marketing.
Open: OpenRouter key structure per project; Supabase project placement; when to productize for outside customers.

Mission Control

Watch the work happen.

Mission Control is the live window onto a run — and the human's entire workspace. The prototype below is a working, animated simulation of a full run for a fictional product ("PermitPilot"); it doubles as the UI spec for the real dashboard.

Open Mission Control LIVE → Animated prototype (simulation)

LIVE is real now: the live page reads actual run telemetry — every event, vote, cost, and gate from real Crucible runs — and renders the actual artifact documents (thesis, research, dossiers, scores, plus the factory's own phase specs under _FACTORY). It updates within seconds of the factory doing anything.

What to try

Use SIM 1× / 4× (top right) to fast-forward the simulation.

Watch the thesis tournament: three generators writing, adversaries filing objections, judges scoring blinded candidates and voting, synthesis committing the FINAL.

When the amber human gate opens, click Open review — the thesis renders as a typeset document with every objection anchored to its section. The review clock starts only then.

Hover any section and attach a note, then choose Revise synthesis with notes — V2 comes back with only the changed sections highlighted. Or re-run the whole tournament (or the research phase) with your notes injected.

Hover any model name for its provenance card: provider, lineage, context, pricing, live spend this run, and its factory record from the ledger.

Check the Factory Floor tab — human minutes per product is the headline stat — and the streaming run ledger at the bottom of the run view.

Showcase mode (planned): because the dashboard is a pure reader of the event stream, the same UI can replay any completed run with a playback clock — scrub, pause, and show a room how a product was born.

Models & Roster

Hired on evidence, not on vibes.

Crucible doesn't ask "which model is best?" It assembles a room that argues — then keeps score.

The four selection principles

Diversity is the product. Generators are always one per AI family (OpenAI, Anthropic, Google, wildcard). Three flavors of one family produce three dialects of the same document.

Judges never score their relatives. Models measurably favor their own family's prose even when blinded — so judge families are drawn from outside the generator pool (xAI, DeepSeek, Mistral).

Spend by stakes. Frontier models for thesis and architecture; workhorse tiers for stories and test plans; the expensive phase is always the build swarm, not the documents.

Match the model to the cognitive job. Generators need range; adversaries need reasoning depth; judges need rubric discipline and clean structured output; the synthesizer needs long context and the best prose on the roster.

The roster is config, and the config learns

models.yaml holds named pools with exact version-pinned OpenRouter IDs. At every run start the roster-scout skill checks OpenRouter for new releases, price changes, and deprecations, reads the cumulative record, and proposes the lineup — including one audition slot: a newcomer gets a fourth generator seat, earns a permanent place at two tournament wins, or exits at 0-for-4.

After every run, the ledger rolls up per model: tournament win–loss, adversary kill rate (what % of filed objections changed the final artifact), judge agreement with human gate decisions, and cost per win. That record travels from project to project in roster-history/ — so within a handful of runs, model selection stops being opinion.

In Mission Control, hovering any model name shows its provenance card: who makes it, lineage and release, context window and pricing (from OpenRouter), spend this run, and its factory record. The card blends what the vendor claims with what the model has actually done here.

Marketing Board · Phase 12

Five schools of thought, one campaign portfolio.

After the product ships, the pipeline doesn't stop — it convenes a board. Unlike the tournaments (three interchangeable generators doing the same task), the board is deliberately heterogeneous: five doctrine skills, each codifying a marketing school of thought as testable principles, heuristics, and fatal-flaw checks. Doctrines, not impersonations — improvable, gradeable, and sellable without implying anyone's endorsement.

LENS 01

Offer economics

Value equation, guarantee design, price-to-promise ratio. Attacks weak offers before creative is ever discussed.

LENS 02

Positioning

Competitive alternatives, category choice, who it's for. Decides the frame every other lens must work inside.

LENS 03

Direct response

Hooks, proof, one big idea, measurable response. Owns anything with a CTA and a budget.

LENS 04

Brand & story

Remarkability, permission, word-of-mouth mechanics. Argues for the plays that don't show ROI in week one.

LENS 05

Growth engineering

Loops, channels, CAC math, funnel instrumentation. Turns the other lenses' ideas into measurable systems.

STANDING ADVERSARY

Compliance

Meta ad policy and platform rules applied to every proposal — the cheapest place to catch a campaign that can't legally run.

The boardroom protocol

Independent proposals — each lens reads the thesis, PRD, and pricing, and proposes its top two campaigns with expected-ROI reasoning. No cross-contamination.

Debate round — each lens critiques the others' proposals through its own doctrine. This is where heterogeneity earns its keep.

Chair synthesis — a chair model assembles the portfolio: which 2–3 campaigns, sequencing, budget split, KPIs.

Human gate — approve the portfolio.

Every approved campaign becomes a standardized brief — audience, channel, offer, hook, creative requirements, budget, KPI, compliance notes — deliberately written so any execution tool can consume it later (Metricool, Meta ads, HeyGen/UGC, Vercel landing pages). The brief is the socket; the tools are plugs, chosen later.

The loop closes on reality. Shipped campaigns return real CPL and conversion data to the ledger, next to the lens that proposed them. Marketing is the one place Crucible's judges eventually get graded against the actual market.

Decisions

The decision log.

Every locked decision, dated. If it's not here, it's still open.

Date	Decision
2026-08-30	Name: Crucible (by Near Zero Labs). Forge rejected — live Autodesk registration in our services class plus extreme namespace crowding. Preliminary research rated Crucible medium-risk with no live blocking registration; attorney clearance pending (watch: Atlassian residual rights, Dreadnode). Grab `getcrucible.ai` + `crucible.dev`.
2026-08-30	Each product is its own repo created from a template; factory logic lives only in the `crucible` repo.
2026-08-30	Files-in-git are the backbone; the dashboard is a pure reader of the event stream (which is what makes showcase mode free).
2026-08-30	Judging is blinded; judge families never overlap generator families; model versions are pinned, never "auto".
2026-08-30	Test plan is written before code; interface contracts freeze before the build swarm starts.
2026-08-30	Human minutes are measured click-to-decision only, and it's the headline metric on the factory floor.
2026-08-30	Gates carry an autonomy dial (approve → veto window → autonomous); promotions are earned via ledger evidence; the thesis gate stays human.
2026-08-30	Gate reviews happen inside the product — typeset artifact, anchored commentary, section notes, and four decisions: approve, revise synthesis, re-run tournament, re-run upstream.
2026-08-30	Marketing experts are doctrine skills (schools of thought), never named-person impersonations. Phase 12 decides; execution tools plug in later.
2026-08-30	Intake is web-first: describe + upload docs/research + optional questions (never required) + a "Let's go" kickoff whenever the founder says so.
2026-08-30	Coding happens in Claude Code on a real filesystem, not in the web app. The handoff is the repo itself: factory-written CLAUDE.md carries contracts, story IDs, and ledger rules; Mission Control observes and gates. Human dev sessions log to the same ledger.
2026-08-30	Harness doctrine — freeze the criteria, free the learnings. Feature lists, contracts, and done-definitions are agent-read-only (only the orchestrator or a human gate mutates them); progress notes and failed-approach logs are agent-writable. Builders never self-certify: the orchestrator flips `passes` on externally-run green tests, and every completion claim faces a criteria-vs-evidence challenge.
2026-08-30	Showcase mode is a first-class requirement — an NZL sales asset, not an afterthought.

Worklog

Kept current as we build.

A dated record of what actually happened, newest first. Updated every working session.

2026-08-31 · Session 2

First live run in flight: TradeClear thesis through three gate rounds; harness hardened by contact with reality

PermitPilot run, phase 02: thesis tournament completed live — Gemini 3.1 Pro's candidate won 2–1 (DeepSeek dissenting), 41 adversary objections filed, 14 fatal; synthesis produced "TradeClear," a verified-answer + filing-prep engine whose credential boundary and honest market math are direct products of the adversarial round. Actual OpenRouter spend across all attempts: ~$7.
Human gate working as designed: founder objection ("contractors already know their towns") drove a v2 revision that re-centered the value prop on change-detection, turnover insurance, edge scopes, and growth — plus a validation plan with kill/green-light thresholds and a memory-versus-source field test, anchored on WhoHire-customer interviews. A verified landscape dossier (PermitZone, iPermit, PermitFlow, Permitio, Symbium, Shovels) then exposed two unverifiable stats and a stale competitor claim → v3 corrections round.
Harness upgrades shipped from the run's failures: transient provider errors retry with backoff; malformed judge JSON re-asks; truncated outputs are refused, never shipped (token ceiling raised to 24k); stage checkpointing means a mid-tournament crash resumes without re-spending completed stages; synthesis emits FINAL.json machine extracts.
Landscape dossiers are now part of the harness: research auto-identifies the market's key entities and deep-dives each before any gate (plus crucible dossier "<entity>" on demand); the thesis prompt and rubric now require market-entry completeness — distribution & right to win, switching costs vs. status quo, moat & platform-risk kill-shot, buyer payback economics, exit landscape (20% of judge score).
The web gate is real — human-in-the-loop moved into the browser: when a run hits a gate, /live shows the amber banner; Open Review renders the actual artifact with the panel's votes and adversary counts from the ledger, the human-minutes clock runs click-to-decision, and Approve / Revise-with-notes / Re-run / Stop land in a decisions channel the factory polls and consumes within seconds (verified end-to-end; try project "demo-gate"). A permanent Human Loop panel shows gate history and human time even when no gate is open. Artifacts browser upgraded: collapsible bins per pipeline stage, ★ FINALs, and a ledger-derived ORIGIN strip on every document (which model wrote it, in what role, when). Outage hardening: network failures pause-and-wait instead of burning retries, and crucible run --auto self-restarts from stage checkpoints.
Mission Control went LIVE: crucible.nearzerolabs.com/live now renders real run telemetry — every event, vote, and gate from actual runs, polling a Supabase event store the factory mirrors into (key-checked ingest RPC; tables read-only to the public key) — plus an artifacts browser that renders the actual documents of every phase (FINALs, candidates, objections, scores, dossiers) and the factory's own phase specs (prompts & rubrics) under _FACTORY. crucible sync backfills any project.
Anthropic long-running-agent doctrine review adopted into the build order (resume, frozen criteria / free learnings, orchestrator-only pass-flips, completion challenges, serial merges).

2026-08-30 · Session 1

Architecture designed, Mission Control prototyped, name chosen, hub launched

Full factory architecture designed: tournament machine, 12-phase pipeline, adversarial review, blinded judge panels, synthesis, run ledger, per-project repos from a template.
Existing skill inventory audited — the wh-* development workflow and ~15 PM/strategy skills mapped to pipeline phases for genericization.
Mission Control prototype built and iterated three times: v1 live tournament bracket + phase track + cost ledger; v2 in-product gate review drawer with section notes, revise/re-run paths, and the human-minutes clock (click-to-decision rule); v3 model provenance hover cards. Full gate loop verified in-browser.
Near Zero Labs framing locked: human minutes per product as headline metric, autonomy dial on gates, showcase mode as a sales asset.
Marketing board designed: five doctrine lenses + standing compliance adversary; campaign briefs as the execution socket.
Name research: Crucible selected; Forge rejected on trademark grounds; domains to acquire identified; attorney clearance flagged.
PRD v1.0 written. This overview hub built and deployed at crucible.nearzerolabs.com (code 3003).
Factory scaffolded at ~/Vera/crucible (git repo, first commit): tournament engine with enforced family diversity + blinded judging, append-only ledger with Supabase mirror, terminal gates with retry cap, project template with CLAUDE.md handoff, and crucible roster check — which validated the full roster against OpenRouter\'s live model list (all IDs pinned and green).
Web-first intake designed and prototyped: describe + upload docs + optional questions + "Let\'s go" kickoff (New Run screen in the Mission Control prototype).
Human-minutes baseline stat set to ~150 min/product.
PermitPilot — first live run started. Real project, real money: research phase complete (4 lenses; PermitFlow, iPermit, and the municipal-platform landscape mapped with citations); thesis tournament in progress. Shakedown bugs found and fixed: provider rate-limits now retry with backoff; malformed judge JSON now re-asks instead of failing the run.
Harness doctrine adopted: a research agent read Anthropic's two long-running-agent posts against Crucible's design. Verdict: the tournament engine already solves artifact quality; the posts supply what the build swarm was missing — sessions die as the normal case, the environment is the only memory, criteria stay frozen while learnings stay free. Build order updated accordingly (resume, FINAL.json extracts, orchestrator-only pass-flips, completion challenges, serial merges).

Next up

First live run

First live run: phases 00–05 on a real product idea to tune the rubrics; then the Supabase event schema and Mission Control v1 against the prototype spec (including the New Run intake screen).