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.
Multi-store for a garment wholesaler
agent repaired 4 reuse findings · passedVerified at build time — if a number here is wrong, the build fails
Build it, secure it, run it — on the same spine
One platform, three planes. Every product on it plugs into the same governed core.
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 →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 →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.
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.
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.
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.
Rigour by stakes
A workspace belongs to exactly one track. The track decides which stages apply and how many gates block.
| Track | Ships to | Gates | What it forces |
|---|---|---|---|
| Build or edit a web app | production | ◆ ◆ ◆ | 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 prototypes | nowhere | — | 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 code | pull 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 content | production | ◆ | 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 sites | production | ◆ ◆ | 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-commerce | production | ◆ ◆ ◆ | 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. |
| Personalization | production | ◆ ◆ | 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.
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.
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.