AI writes the code. A named human signs it. Every change ships with a re-runnable trail of proof — so when it breaks at 2am, there's a record and a person, not a hunch.
auth/session.ts to use httpOnly cookies.The agent doesn’t act on guesswork and we don’t ask you to either. Every claim has a source. Every source is checkable. The trail outlives the run — re-run any check months later to detect drift.
Before any code touches your repo, the agent drafts a plan: which files it will touch, which libraries it needs, which sources it intends to cite. You can revise the plan or veto it.
Every claim is checked against the source it cites. Pinned versions, vulnerability scans, license clearances, doc-matching, test suite. Failures stop the run and surface in the trail — the agent does not paper over them.
An engineer reviews the agent's work, the provenance trail, and the verification results. Nothing ships without a human taking responsibility. The trail is archived so you can re-run any check months later — including after a dependency update.
What a developer-agent commit looks like when it lands. Code on the left. The provenance that makes it merge-able on the right.
@@ -12,9 +12,14 @@ export async function setSession(payload: SessionPayload) {− const token = sign(payload, env.SESSION_SECRET)− document.cookie = `sid=${token}; path=/` + const token = await sign(payload, env.SESSION_SECRET)+ const cookieStore = cookies()+ cookieStore.set("sid", token, {+ httpOnly: true,+ secure: true,+ sameSite: "lax",+ maxAge: 60 * 60 * 24 * 7,+ })Every project runs on isolated Kubernetes with its own namespace or dedicated cluster. Agents are autonomous software — their access is controlled, auditable, and revocable. Here is what ships by default.
Every agent session gets fresh credentials. They expire in minutes, not months. The blast radius of a leak is bounded by the clock.
The policy engine rejects cross-tenant access before the request reaches storage. Per-tenant keys, audited per call.
A delete request destroys the customer’s encryption key. The data becomes mathematically unrecoverable — including from replicas and backups — in seconds.
Every read, write, and revocation is signed and replayable months later. If audit logging fails, the service halts rather than running blind.
Format-preserving tokenization at the application layer. The agent works with tokens. Your joins still work because the token shape is stable.
One call invalidates the token. Database users, certificates, storage tokens — everything the agent touched is revoked in the same operation. Recorded in the trail.
The agents do the volume and the verification. A human engineer reviews and signs everything before it ships. You can also run any agent inside your editor via MCP — against the model you’re already paying for.
Writes, reviews, refactors, tests.
Every change ships with a provenance trail. Sources cited, versions pinned, vulnerability checks run, license clearances confirmed, fact-checks against current docs. Every function ships with tests. The agent refuses to ship code it can’t cite and hands off cleanly to a human reviewer.
Thinks in tokens, not screens.
Generates components, screens, and design systems that compose. Catches off-system colors, radii, and spacing before they ship. Outputs Figma libraries and code in step.
Reads the fine print so you don’t have to.
Reviews license compatibility, terms of service, and regulatory requirements for every dependency and integration your project touches.
Provisions infra, watches your logs.
Provisions your environment on isolated Kubernetes, configures CI/CD and GitOps, deploys services from the catalogue, and monitors logs and alerts. Currently in alpha.
Side by side with the tools founders are already using. Reflects publicly documented behavior as of June 2026. We re-check it quarterly; if something here is wrong, tell us and we’ll correct it.
| Capability | launch.ist | Lovable | v0 | Cursor |
|---|---|---|---|---|
| Source-cited provenance, by default | ● | — | — | — |
| Pins dependency versions on output | ● | — | no (`latest`) | — |
| Runs <em>your</em> test suite as a merge gate | ● | — | — | optional |
| CVE / vulnerability scanning | ● | ● | partial | opt-in* |
| License / SBOM checks | ● | — | — | — |
| Human engineer signs the merge | ● | — | — | — |
| Isolated infrastructure you control | ● | — | — | — |
| Production infrastructure included | from $59/mo | — | — | — |
| Re-runnable provenance trail | ● | — | — | — |
| Immutable audit trail | ● | — | — | — |
Reflects publicly documented behavior as of June 2026. *Cursor’s vulnerability scanner is opt-in, beta, and Teams/Enterprise-only — off by default. We re-check quarterly; if something here is wrong, tell us and we’ll correct it, with credit.
No "contact sales" hiding the cost. Posted plainly. If something here is wrong for your situation, email us — we'll tell you the price.
Staging, dev, preview environments.
First production app.
Growing production workloads.
Production at scale.
We started as a traditional dev agency. We were good at it. But every founder who used to hire us could now type a sentence into Cursor and get the same thing in an evening. The labor we sold was being commoditized.
What wasn’t being commoditized was responsibility. The output from those tools looked right, sometimes shipped, sometimes blew up at 2am because a library had quietly changed its API. Nobody could tell which kind of output they had until it was in production. And nobody was accountable.
So we rebuilt the agency around that gap. We still have human engineers — they review, they sign, they take responsibility. But now they work alongside specialist agents that handle the volume and the verification. The agents do the heavy lifting. The humans own the outcome.
If you’re a founder shipping at midnight, the value proposition is plain: work with us and you ship something a human checked and signed. If something breaks later, you have a trail and a team to call, not a hunch.
That’s the whole pitch. Sign up, kick the tires for free, and email me directly if it doesn’t hold up.
Updated as new ones come in. Email hello@launch.ist if yours isn’t here.
No. The model is one layer. The verification apparatus around it — version pinning, source citation, doc-matching, CVE checks, license clearances, test enforcement, drift detection — is the product. You can swap the model and the verification still holds.
The agents are MCP-native, so you can run them against the model you’re already paying for in Cursor or Claude Code.
Infrastructure starts at $59/mo for a dev/shared namespace and scales to $649/mo for a dedicated production cluster with 64 GB RAM, HA Postgres, and full catalogue. Every tier includes GitOps, CI/CD, TLS, and observability. Human review — a senior engineer who personally signs the work — is $2,500 per launch.
A readable, replayable record of how a change was made: the plan, the sources consulted, the verifiers that ran, the versions pinned, the tests that passed, and the human who signed off. Stored as JSON + Markdown and served at /launches/<date>/<sha>. It’s designed to outlive the run — re-run any check months later to detect drift.
Not without a human merging the PR. The agent opens branches, runs verifiers, and surfaces a diff. Merging is a human action by default. Business and above adds optional auto-merge inside a policy you define.
The default stack is Claude Sonnet for planning, Claude Haiku for verifier loops, and GPT-4 class for second-opinion review on the human-review tier. You can override any of these per-project. We pin model versions the same way we pin library versions.
Dev/Shared and Starter: code is processed in-flight and never used to train models. Business and above: a senior engineer reads your repo; self-hosted runners available. Audit logs on by default at Starter and above.
A development agency that uses specialist agents to do the heavy lifting. The agents handle code, design, compliance, and infrastructure. The humans review, sign, and take responsibility. You get agency-grade outcomes at a fraction of the cost because the agents handle the volume.
Architecture, CI/CD, tests, isolated Kubernetes, and specialist agents — from $59/month. Human engineers review and sign everything.
Drop your email. We’ll create the account and send a magic link.
Both agents, unlimited runs, private repos, full provenance log. We won’t charge until day 15 — and we email a reminder on day 12.
We’ll email you a magic link. No passwords.
Tell us what to ship. We’ll scope it in writing, then build and sign it. 2–5 business days.
Tell us about your team and use-case. A senior engineer answers — not a sales sequence.