rathvan_
Console Start a build
The spec-driven build platform

Agents write the code. You decide what ships.

Describe the product. Rathvan turns it into a reviewed spec, a buildable repository and a governed pipeline — every step gated, nothing fabricated, built on one shared, audited spine. Self-hosted, with row-level security enabled and forced from the first commit.

Open the builder See a real build npx rathvan new ./your-product
Behind FinSetuDocConnectFoilVerify · forced row-level security · hash-chained audit · ports & adapters
builder.rathvan.com/console
01 Reuse map
02 PRD
03 Architecture
04 Design
05 Build
06 Test
◆ Gate · staging
Build spec · v1

Multi-store for a garment wholesaler

agent repaired 4 reuse findings · passed

Verified at build time — if a number here is wrong, the build fails

139capabilities to reuse
3012kernel tests, zero skipped
142migrations, RLS forced
3gates a person must stamp
0paths to production without one

Build it, secure it, run it — on the same spine

One platform, three planes. Every product on it plugs into the same governed core.

B

Builder

From a prompt to a reviewed spec and a repository you can build. The agent clears the quality gates itself and only stops you for the decisions that are yours.

Open the builder →
S

Security Hub

Identities for people and agents, single sign-on, threat classes and adversarial campaigns — the governance plane every product plugs into.

See the Security Hub →
P

Platform Hub

Observability, logging, alerting, a gateway and a model router. One place to watch and steer everything running on the platform.

See the Platform Hub →

Describe it. Watch it think. Decide what ships.

Three moves from a sentence to a repository your auditors would recognise.

01

Describe what you want

Plain language in. The builder asks only what it genuinely needs, then drafts the PRD while you do something else — no staring at a blank screen.

02

Watch it think, then decide

A live stream shows each stage, step and outcome as the agent works. It fixes its own lint and reuse errors and brings you a finished spec to approve, not a wall of warnings.

03

Ship through the gates

A buildable repository, characterization tests, and a pipeline that ends at a human gate before anything reaches production. You own the moment it ships.

The pipeline is the product — and it is generated, not drawn

The same rows the console renders for a running build, from the same manifest. One artifact, not two descriptions of it.

Pipeline · 14 stages3 blocking
01–05Reuse map → Design5 automatic stages, graded by programs and repaired before you see themauto
◆Gate 1 — agreementScope cannot be inferred from a one-line prompt, and reuse-vs-rebuild is decided herehuman
06–10Test strategy → Deploy5 automatic stages, graded by programs and repaired before you see themauto
◆Gate 2 — staging to productionThree deploy failure modes are invisible to every automated signal — wrong stack, pinned traffic, empty bodieshuman
11–14Observability → Operational readiness4 automatic stages, graded by programs and repaired before you see themauto
◆Gate 3 — declare liveA capability is done when someone who did not build it can operate ithuman

Rigour by stakes

A workspace belongs to exactly one track. The track decides which stages apply and how many gates block.

TrackShips toGatesWhat it forces
Build or edit a web appproduction◆ ◆ ◆All 14 stages, all three gates, nothing relaxed. Editing an existing codebase is the harder half — bounded ownership, minimal diff, and the reuse map is the entire job.
Create prototypesnowhere—Tightens the two stages people skip; relaxes the rest. A prototype must be structurally incapable of shipping — separate namespace, no production credentials, an expiry. Promotion is a restart, not a merge.
Convert designs to codepull request◆Round-trip fidelity or bounded ownership — a generator that rewrites a component discards every hand-edit since. Tokens are a failing gate, not a review comment.
Manage contentproduction◆Publishing changes data, never code. If a content change needs a build, an engineer is back in the loop and “without developer dependency” is false.
Marketing sitesproduction◆ ◆A marketing page fails invisibly. Deep-link objects must exist — a 404 rewritten to 200 renders as a blank page with an empty console. Verify by downloaded size, never status code.
E-commerceproduction◆ ◆ ◆Everything tightened, plus the full security pass. The amount is server-priced from the catalogue, always. Not yet in the kernel: catalogue variants, cart, inventory, fulfilment, returns, tax.
Personalizationproduction◆ ◆Never average across variants — the aggregate hides the losing one. Assignment must be stable and recorded, and the stopping rule is decided before launch.

A refusal, in full

Proof is a real run that stopped, not a happy path.

rathvan run --workspace courier-ops
→ 09 gate tests       13 gates · 12 passed · 1 failed
✗ ReuseLint           architecture references types that do not exist
                     · DispatchWindow      no such type in catalogue or scaffold
                     · Courier.reassign() no such method on Courier

◆ build halted at stage 09  state: STAGED → held
   nothing written to source control · nothing deployed
   audit: run.gate.refused actor=system/ReuseLint 2026-09-11T04:18:22Z

Already have code? Reverse-engineer it. Migrate it. Rebuild it.

Point it at a repository that already exists and it works the harder half: understanding code it did not write, then moving it forward under the same gates.

Make legacy agent-ready

It maps the code and scores readiness and risk — hotspots, cycles, end-of-life — then writes the docs, characterization tests and CI that let agents work on it safely, and modernizes a slice at a time, each behind a human gate.

Map→ Assess→ Docs · tests · CI→ Modernize a slice

Reverse-engineer and rebuild

It recovers a specification from the code — every claim tagged source or inferred, nothing copied verbatim — then forward-builds a fresh, gated implementation. Regenerate it in a new stack, split it into services, or synthesise one product from several repositories.

Learn→ Recover spec→ Rebuild→ Prove parity

Honest by design: the source licence is respected, nothing is copied word for word, and parity is claimed only where a test pins it.

Start with a sentence.

Describe your product and watch the builder turn it into a repository your auditors would recognise. You approve the gates.