Open source · Local first · Evidence backed

Create your reviewable MVP. See its proof in minutes.

Why pay for opaque app generators? Create a reviewable MVP starting state in minutes—with local receipts, a clear proof path, and an output you can extend when you are ready. Use the same proof context in Cursor or OpenCode through local MCP.

Start free with pip Watch the exact 60-second UI

✓ Verified release checks ✓ Release test suite passed ✓ 8-IDE compatibility matrix ✓ No source upload

Actual Factory Studio showing the outcome-first MVP path and explicit local-only authority boundary. — Actual Factory Studio product capture · outcome-first MVP · local-only boundary

Feel the proof path before you install.

A no-signup browser preview turns one outcome into a reviewable shape. It is a local product tour, not a production mission and never sends your text anywhere.

Public proof playground

Tell the factory what “done” should mean.

Choose a starting point or write your own. The preview shows how Code Factory makes intent, checks, and receipts visible before you run the real command.

Your proof receipt will appear here.
Start with an outcome and watch the line assemble.

Proof, not promises.

Each stage produces an artifact a reviewer can inspect. A fresh starter remains blocked until product-specific tests replace hollow coverage.

01 · Define

Lock the intent

Turn requirements into a bounded spec and an explicit architecture contract.

02 · Challenge

Sabotage the gates

Delete, invert, and corrupt critical controls. A surviving mutation blocks the claim.

03 · Route

Choose models under rails

Select provider and model references by IDE, quality floor, budget, and cache continuity without storing keys.

04 · Ship

Carry the evidence

Hash-link receipts and release artifacts so reviewers can reproduce the decision.

From first MVP to the exact proof path.

These are real local product captures, not concept art or a simulated IDE. The Marketplace media set remains IDE-native and review-gated.

Factory Studio showing the outcome-first MVP and professional workflow tabs.

Factory Studio Graph Ops showing local graph lanes, proof counts, and a fact-derived next action.

Two-minute start

Run First Proof

Install FactoryLine, confirm the local workspace, then create a contained MVP. The exact listing copy and capture brief are public in the Marketplace Acquisition Kit.

Open the kit →

Start from a useful recipe.

These are outcomes people can recognize in one glance. Copy the command, then adapt the spec and keep the proof boundary.

Audit

Repository readiness

Find missing tests, contracts, and proof inputs before an agent changes code.

factory coverage --root . --json

Build

Contained MVP

Turn a plain-language outcome into a reviewable local starter with explicit gaps.

factory mvp "Build an approval tracker" --root .

Inspect

Graph Ops map

See products, missions, proofs, gates, traces, and artifacts without executing them.

factory graph ops --root . --json

Verify

Independent verifier

Bind worker output to distinct checks and reject self-grading or byte drift.

factory verifier verify ... --json

MCP recipes

Bring the same proof context to your client.

Use the read-only local MCP server from Cursor or OpenCode. The connection exposes Graph Ops facts; it does not upload source or grant release authority.

✓ Local · read-only · provider keys stay with you

factory mcp serve --root .

Choose your lane

Copy the smallest setup.

Cursor recipe →
OpenCode recipe →
MCP contract →

✓ Read the contract before connecting

"factory": {
  "command": "factory",
  "args": ["mcp", "serve", "--root", "."]
}

Start with an outcome

Build an MVP now. Add enterprise rigor when it earns its keep.

Use one outcome-first command for a contained local web MVP, then retain the same artifact path as you add proof, Graph Ops, team review, policy, assurance, and tenant controls. The factory does not switch into an autonomous publisher at any stage.

factory mvp "Build an approval tracker" --root .
factory coverage --root .\my-mvp --json
factory graph ops --root .\my-mvp --json

New in 0.24

See the whole proof path, safely.

Unified Graph Ops connects the local Product Graph, value slices, missions, approvals, completions, proofs, gate plans, traces, receipts, and artifacts into one bounded visual result. It recommends one next action from current facts and never executes a gate or release action.

factory graph ops --root . --json
factory graph ops --root . --mermaid
factory studio --root .

New in 0.28.0

Keep the builder and verifier independent.

Proof Review, Verified Repair Sandbox, and Workspace Load Advisor make the local handoff visible before a repair or environment change. The Verifier Plane binds a worker receipt to distinct verifier evidence, immutable check files, deterministic checks, and hard budgets. These surfaces never edit code, call a model, or claim a production sandbox. Start with factory prd grill PRD.md --root . --mode quick.

factory verifier session .factory/missions/<mission>/mission.json ./candidate \
  --bundle ./verification/checks.json --owner engineering-owner --root .
factory verifier verify ./session.json ./worker-result.json ./verifier-result.json --root . --json
factory verifier progress ./attempts.json --json

New in 0.23

Reuse the proof. Keep the boundary.

Content-addressed receipts route read-only gates to RUN, REUSE, SKIP, or BLOCK. Exact reuse verifies every bound input and output; ambiguity runs again, and side effects stay blocked.

factory proofs record proofs.json \
  --gate python-tests --elapsed-ms 600000 --root .
factory proofs plan proofs.json --changed src/app.py \
  --auto-savings --out proof-plan.json --root .

Two-minute first run

Start locally. See the next proof gap immediately.

Create a contained MVP, then let Graph Ops reveal the requirement or receipt that needs evidence. A starter is useful starting state, not a readiness claim.

Start free with pip Watch the shipped UI walkthrough Install free in JetBrains

pip install factoryline-code-factory==0.28.0
factory mvp "Build an approval tracker" --root .
factory studio --root .\my-mvp
# Open Graph Ops in the local Studio

Launch terms

Free through 2026. Clear before the paid change.

All features are free through December 31, 2026. A $4.95 USD monthly Marketplace price is planned for January 1, 2027, subject to JetBrains paid-plugin approval and a planned 30-day trial. No checkout is live; total price, taxes, fees, and billing terms must be shown before any approved purchase.

Marketplace count: check the current listing
Unique installs: not exposed by the listing
0.8.4 update: pending Marketplace approval

Never substitute CI or repository traffic for installs.

The factory line, illustrated.

A conceptual walkthrough of verification, signed proof, and the split between accepted and rejected artifacts.

AI compiler stack with Python and security contracts.

Robotic magnifiers inspect passing checks and a deliberately broken check.

Signed receipts travel through a proof chain and split into accepted and rejected paths.

Concept illustrations—not UI screenshots or measured outcome evidence. Open all nine stages →

Make the next change carry its own proof.

Start free with pip Install free in JetBrains Inspect or star on GitHub