LLMs advise. Deterministic code enforces.
Lailya sits between your AI assistants and your repository. Every proposed change is classified by a deterministic policy engine, reviewed adversarially by a second independent model, and written to an append-only, hash-chained evidence ledger, before a human approves anything irreversible.
A looping demonstration of the evidence ledger. Seven fields print one at a time: the engine derives Tier 3 while the model claims Tier 2, the contradiction routes the run to a hold, and the verdict is HOLD, cleared only by a revised proposal. A five-block SHA-256 chain then verifies, and a final beat shows a tampered block breaking every link after it.
Green doesn't mean good.
Watch a pipeline pass. Then watch what it actually verified. Every failure below was found in a real production codebase, by the audit that produced Lailya.
A looping demonstration of a continuous integration run. Four checks pass and the pipeline reports success, then the same run is re-read honestly: no tests were executed, no apps were typechecked, no boundaries were verified, and more than a hundred type errors were counted while the gate still displayed PASSED. Use the two buttons below to compare the two readings.
The test that ran zero tests
A contract-test step pointed at a missing directory. Under continue-on-error it executed nothing and reported success.
CI green that gated nothing
The pipeline typechecked shared packages only, while one app carried ignoreBuildErrors. Both statements were true, and both meaningless.
The drift checker that lied
A schema-conformance script with a fragile fallback reported healthy tables as missing. A checker that lies costs more than no checker.
The human as integration bus
Every proposal, verdict and evidence blob copy-pasted by one person between three AI systems, including a secret silently truncated in transit.
Nothing here asks a model what it thinks.
Pick a change. The engine walks the same seven rules against its paths and effects, and the tier falls out of the match, not out of a prompt.
A looping demonstration of the classifier. For the change selected on the left, it walks seven rules with tier floors of 0, 1, 2, 2, 3, 3 and 3, and the resulting tier is the highest floor matched. Choosing a change from the list holds the demonstration on that change.
Four steps. One of them is a human, on purpose.
Follow the run as it moves through the gates, or click any step. Notice where it stops.
nothing irreversible has executed
Six modules. Five of them never ask a model anything.
Roles are separated from providers in configuration. Reassigning which frontier model sits in which seat is a config change, not a redesign.
Deterministic policy engine
A pure function over your proposal and a versioned, hashed policy file. Same input, same output, every time.
Adversarial reviewer contract
A different provider, given the raw redacted evidence and an explicit brief to refuse to rubber-stamp.
Secret & injection boundary
Redaction runs at ingestion. Raw input exists only transiently in memory; never persisted, transmitted or hashed.
Append-only evidence ledger
Two tables, no updates, no deletes. A silent edit or a reordering breaks the chain and shows up immediately.
CommandSpec approval gates
A human approves an exact rendered preview; the approval binds to the SHA-256 of the canonical spec.
Objection-rate metering
Lailya measures its own reviewer. If the objection rate collapses toward all-GREEN, the platform says so out loud.
Everyone else is optimising for autonomy. We're optimising for proof.
None of them can tell you, six months later, under which policy version a change was approved, by which model, on what evidence, and whether the review that cleared it was real.
| Capability | Lailya | Autonomous agents | CI gates alone | Manual model-to-model |
|---|---|---|---|---|
| Who assigns the risk tier | Deterministic code, closed allowlist | The model, implicitly, or nobody | Whoever wrote the workflow file | A human, under time pressure |
| Independent review | Required, adversarial, different provider | Self-review by the same model family | None. Checks aren't reviewers | Real, but entirely manual |
| Detects its own degradation | Yes. Objection-rate metering | No | No. A green gate measures nothing | Only if someone notices |
| Audit trail | Append-only, hash-chained, replayable | Chat transcripts and PR comments | Build logs with a retention window | Scattered across three chat histories |
| Secret handling | Redacted at ingestion; never persisted | Whatever is in the context window | Masked in logs, present in the runner | Depends on the person pasting |
| Cost when it disagrees | Hard HOLD; no auto-resolution | The agent picks a side and continues | Not applicable | The founder adjudicates: the failure mode |
Comparison reflects the default posture of each category as we assess it, not a benchmark of any named product.
Doctrine we won't sell you an exception to.
The operating rules, as the policy file the engine actually reads. Not a summary of it.
A looping demonstration of the operating doctrine rendered as the policy file the engine reads. Seven rules print one at a time: a GREEN verdict means safe to try and never proven correct; disagreement routes to a HOLD with no auto-resolution; the operator never adjudicates, only a revised proposal clears a hold; commit and push are each Tier 3 as separate gates; recovery raises the evidence bar and never lowers it; and transport is the official provider API, never browser automation. The footer then verifies the file hash and reports seven rules, zero overrides and zero exceptions granted.
"The friction in our review process was doing real safety work. It was also costing hours a week. Lailya exists to remove the tax without removing the safety. Automate the wiring, never the judgment."
Priced per engineer, not per run.
Model spend goes directly to your providers, never through us, and every run logs its own token cost.
For the founder or single engineer who is currently the entire review loop.
For engineering teams whose audit trail has to survive a due-diligence question.
For teams whose evidence standards are set by a compliance function, not by them.
Prices exclude VAT and exclude model provider usage, which you pay directly.
Tell us what your review loop looks like today.
We onboard a small number of workspaces at a time, because the first thing we do is read your current governance rules and turn them into a policy pack. That is a conversation, not a signup form.
The questions we actually get asked.
No, and that is the point. Lailya governs the change: it structures the proposal, classifies the risk, runs the independent review, and holds the evidence. Your engineers and your AI assistants still do the writing.
Roles are bound to providers in configuration, not in code. The default pairs two frontier models from two different providers, because independence has to be structural: the reviewer should not share a training lineage with the proposer.
Only ones a human has explicitly approved, and only in the exact form approved. The approval binds to the SHA-256 of a canonical command spec, and the runner executes the structured argv form inside a single declared path, never an interpolated shell string.
Three things. It receives the raw redacted evidence rather than a filtered account. It is prompted adversarially and must address tier, scope, command safety, secrets and stop conditions explicitly. And we measure it: if the objection rate collapses toward all-GREEN, the workspace is flagged as degraded.
Then you should stop using it, and we will say so. The product ships with a kill criterion: after ten real governed tasks, if it is not demonstrably faster than your manual baseline, or if review quality degrades, the trial has failed.
Lailya is a blend of the founder's daughters' names. It is a governance product built by someone who intends to still be around to answer for it.
Your AI can propose anything.
It shouldn't be able to approve anything.
Put a deterministic gate between the two, and keep the evidence.