Proof-before-Done · coming soon

Your AI says the work is done. LASDK makes it prove it.

A completed workflow is not completed work. LASDK sits above whatever AI harness you already run and withholds “done” until the evidence earns it. Your models, your machine, your keys — no markup, no credits.

Not released yet. LASDK is in active development and is not available for use. Nothing below is on sale today.

harness-agnostic · runs above your tools evidence you can re-verify refuses unproven Done
Above your harness

It reads the evidence, not the summary.

Point lasdk assess at any run directory that carries the LASDK evidence contract — its own runs do by default, and another harness’s output can be converted to it. It reads what was promised against the evidence on disk, then admits or refuses the “done” — without re-running anything. A verdict is a statement about evidence, not a warranty about your software. ARTIFACT_READY is admissibility, not production approval: LASDK does not guarantee that code it assesses is correct, complete, secure, or fit for your purpose. A person owns the final call. Watch it turn one down →

It refuses, and says why

You get named obligations, each one admitted or refused against evidence you can open and re-check yourself.

Your model, your machine

Bring any AI CLI. Nothing is uploaded or indexed. You pay your provider directly — no markup, no credits.

Runs your process

Your repos, tracker, QA rules and roles live in one shareable sdlc.md that the run actually follows.

How it works

Six stages. You pay for four.

Four of them are model-driven — those are the calls you pay your own provider for. Signal and Audit are fixed steps with no model call. Watch a real one →

Signal Contract Architecture Implementation Critic Audit
Evidence, not screenshots

Every run leaves a record you can open.

Rendered from real governed runs on this project — not a mock-up.

A static control tower, generated from the run directory. Nothing is uploaded to produce it.

Prove it, all the way down

Including the copy you downloaded.

A tool that refuses unproven work should not ask you to trust its own installer. Every kit ships a signed manifest covering every file, and the signing key is compiled into the binary — so a tampered download cannot re-sign itself.

Pricing

The governed SDLC — one simple price.

You pay your model provider directly. LASDK adds no token markup and no usage credits.

What you need to run it: LASDK drives your own AI. It does not include a model. You bring an active LLM subscription or API access (Claude, OpenAI/Codex, …) and a supported AI coding CLI installed (Claude Code, Codex, …). Everything runs locally with your CLI’s own login, and lasdk doctor checks you’re set up — free.
Founding · first 100
Pro Founding
Govern the work you deliver.
$13 / mo
Founding rate for the first 100 — locked while you stay subscribed.
Standard $19/mo after.
  • Full governed SDLC — Signal → Contract → Architecture → Implementation → Critic → Audit
  • Earned Done — signed evidence + candidate sealing
  • All production roles · personal SDLC profiles · bring your own model
  • Everything re-verifiable locally — you can check the evidence yourself, offline
  • Commercial use · 2 activated devices · updates while subscribed
Pro evidence is real and re-verifiable — attested under your own local authority.
Coming soon
Not yet on sale. The price is published so it is not a surprise later.
Team Per seat
Make that delivery trusted by someone else.
$17 / seat · mo
Founding rate for the first 100 — locked while you stay subscribed.
Standard $24/seat/mo after.
Prove work under an authority a reviewer, client or CI can trust — not just your own.
  • Everything in Pro
  • Organization-signed, versioned SDLC profiles — a policy floor individuals can’t weaken
  • Identity-bound evidence — every governed run is signed by a registered device and bound to your approved policy
  • Acceptance records verified against your registered organization key — a self-signed policy or an unregistered machine is rejected, not displayed
  • Revoke a device or seat and its runs stop verifying · central retention · connectors · seat management
Five Pro licenses can trade evidence. Only Team can issue it under a common organizational authority. Starts at one seat — for the solo consultant who delivers to clients.
Coming soon
Not yet on sale.

Not available yet. LASDK is still being built, and it is not ready for you to rely on. These prices are what it will cost when it is — published now so nothing about them is a surprise later. Want to hear when it opens? Email us.

First Governed Run Guarantee

If a confirmed LASDK defect prevents your first supported governed run from completing, contact us within seven days — we’ll help you resolve it or refund your first payment.

Cancel renewal anytime. Your code and delivery evidence remain yours.  ·  Need org-wide deployment or a private verifier? Talk to us.

FAQ

Questions, answered

What is LASDK?

LASDK, the Local Agentic Software Delivery Kit, turns any AI coding model into a governed software-development lifecycle that runs on your own machine.

Does my code leave my machine?

LASDK does not upload your code, prompts or run evidence to Siklab — it runs entirely on your machine and has no telemetry you did not switch on. Note the honest boundary: LASDK drives your AI coding CLI, and that CLI sends project context to its own model provider under that provider’s terms. We never see it; your provider does.

Which AI models can I use?

LASDK is model-independent — it never talks to a model itself. It drives a supported AI coding CLI with your own login: today Claude Code and Codex. Whichever model those are pointed at is the model you get, and other harnesses can integrate through the LASDK run contract.

What do I need to run LASDK?

An active LLM subscription or API access (e.g. Claude or OpenAI/Codex) and a supported AI coding CLI installed (such as Claude Code or Codex). LASDK includes no model; it drives your CLI locally with your own login.

Is there a free version?

Diagnostics, docs, provider preflight, evidence verification, migration export and the judgement commands lasdk assess and lasdk certify are free — you can check any run’s evidence and gate your own repo without paying. Governed builds, critic runs, evidence generation and earned Done need an active subscription. A 24-hour Pro trial starts only after you activate it and a provider check passes, so setup time never burns it.

Is this graph engineering?

Partly, and the difference is the whole point. Graph engineering says to design the work around the model instead of pouring it into one long chat: split it into steps, pass state between them, and keep the writer separate from the checker — because a model grading its own answer will always like what it sees. LASDK agrees with every word of that. What it adds is enforcement. If the agent that wrote the code is also the one that reviewed it, the run doesn’t get to call itself done; the evidence is marked not independent and the gate refuses. Advice you can follow is not the same as a gate you can’t skip.

It also isn’t a workflow engine. LASDK doesn’t replace LangGraph, n8n or your agent harness — it sits above whichever one you use and decides whether the work they produced can be called finished.

Can the AI just bypass the governance?

In assist mode, it can: the agent chooses to call LASDK, so a rushed one can skip it; that’s a discipline you enforce. In governed mode, LASDK launches and controls the run itself: the agent runs with delivery credentials scrubbed and scoped to the workspace, can’t write to your tree (artifact-only), and can’t reach Done without passing the gate. It’s credential-custody + fail-closed delivery, not an OS sandbox. Use governed mode where it matters.

Ready when you are

Give your AI a lifecycle,
not just a prompt.

From a first solo project to a team’s whole backlog, ship AI-built software you can stand behind: a process that’s the same every time, and proof to back it.