Verification infrastructure · live in private beta

A verification fabric that runs underneath your engineering org and produces trust as an output.

Your team is shipping more code than ever. Most of it written by models. Review can't keep up, bugs leak through, and the gap between "it compiles" and "it's correct" is now a structural problem — not a code review one.

LLM judgment is one component of the fabric. Not the most important one.

Request access → See how it works
fig.01 / org.stack
render: layered
layer 04
Engineers + Product
human
layer 03
LLM code generation
10×–40× volume
layer 02
CI / tests / review
saturated
layer 01 ←
Verification fabric
● produces: trust
01 / The problem

Code generation outran code verification.

Models now write the majority of new code in many engineering orgs. The pipes for trusting that code — review, tests, type checks, manual QA — were designed for human throughput. The math no longer works.

37×
PR volume increase after a team adopts agentic coding tools, observed across early customers.
~6min
Median time a senior engineer can actually spend per PR before review collapses into rubber-stamping.
0 ←
Number of existing tools designed to answer the question your CTO actually has: do I trust what just shipped?
02 / The fabric

Trust is the output. Not a vibe.

A verification fabric is a thin layer that sits between code generation and production. Every artifact passes through it. Every claim — "this is correct," "this is safe," "this matches the spec" — gets evidence attached to it before it earns the right to merge.

fabric · run #00481 · feat/checkout-refactor ● verifying
→ fabric.verify(pr=4812)
├─ spec.extract ............ derived 14 invariants from PR description + linked issue
├─ prop.test ............... 312 generated cases, 312 pass
├─ diff.semantic ........... behavior delta within declared scope
├─ contract.check .......... 4 callers, no breaking changes
├─ judge.llm ............... advisory only · flagged: nullable user_id on line 84
└─ trust.score ............. 0.94 / 1.00 (mergeable, evidence attached)
 
→ verified. artifact: fabric://runs/00481
LLM judgment is in there. It's useful. But on its own, an LLM grading another LLM's code is a vibe check — and a vibe check is not what your CTO is selling to the board.
03 / Components

Five layers. One of them is an LLM.

Every layer produces machine-checkable evidence. The layers are independent, composable, and each one fails loudly so the next can do its job.

fabric.spec deterministic
Specification extraction

Turns PR descriptions, linked tickets, and existing tests into a formal set of invariants the change must preserve. The spec is what gets verified — not the diff.

fabric.prop deterministic
Property-based testing

Generative tests over the declared invariants. Hundreds of inputs, automatic shrinking on failure. Catches the edge cases your unit tests assume don't exist.

fabric.diff deterministic
Semantic diff

Static analysis that surfaces real behavior changes — not whitespace, not refactors. Knows the difference between renaming a variable and silently changing an API.

fabric.contract deterministic
Contract verification

Cross-service guarantees. Tracks how every consumer of a function or endpoint will behave under the change. Breaking changes get caught at the source.

fabric.judge probabilistic · advisory
LLM judgment — the smallest layer

Reads the change for things the deterministic layers can't see: intent mismatches, weird abstractions, code that's "technically fine but obviously wrong." Always advisory, always cross-checked, never the only signal. We are honest about what this can and cannot do.

04 / Built for

Engineering orgs that ship faster than they can review.

  • CTOs and VPs of Engineering Who need a defensible answer to "is the AI-generated code in our product safe?" — beyond trust me bro.
  • Platform & Infra teams Owning the merge gate, the CI pipeline, the deploy story. Looking for the layer that turns volume into signal.
  • Senior ICs drowning in PRs Reviewing 30 PRs a day was already a fiction. Now it's a fiction and a liability. The fabric does the mechanical part.
  • Regulated industries Fintech, health, infra. Where "the LLM said it was fine" is not, and will never be, an audit trail.
integration · 5 minutes fabric.yaml
# attach to your existing PR pipeline
on: pull_request
jobs:
verify:
uses: fabric/verify@v0
with:
threshold: 0.90
block_on_fail: true
 
# that's it. evidence ships with every PR.

Drop-in for GitHub, GitLab, and self-hosted CI. No code rewrites. No vendor lock-in. The fabric reads what's already there.

Stop shipping code you can't vouch for.

Private beta with a small number of teams. We work directly with your platform org to get the first verified PR through in under a week.

hello@revfab.dev →