Self-service · €0 to €2,499/mo · sign up in 30 seconds · 95% no-sales-call

Cryptographically auditable AI for regulated products.
Self-service from day one.

The SaaS for runtime-AI containment. Every LLM call your product makes — bounded by a closed-enum schema, gated by reviewer queue, signed into an L12 receipt chain anchored to Bitcoin, verifiable in 50 KB of plain JS. Sign up free; pay only when you ship to production.

€0

Dev tier · forever

1 spec · 10k entries · the SDK + verifier

€79

Team · per spec / month

usage-billed · scale linearly

€499

Production · flat / month

multi-tenant · federation · 1M entries

€2,499

Enterprise · flat / month

Annex III self-service · HSM hooks · on-prem (roadmap)

The pattern is consistent across regulated-EU operators: ship an LLM feature inside a regulated product without killing audit, liability, or compliance. Vanta and Drata audit the software around the LLM. Credo and Fiddler audit the model's behaviour. LangChain orchestrates it. None of them constrain the LLM's output surface by construction. None of them carry the call into a regulator-verifiable record.

Promethean does. The substrate bounds every LLM call to a closed-enum spec, routes through reviewer-queue when the output is ambiguous, applies the spec's declared fallback when the model fails — and writes one signed L12 receipt per decision into a chain anchored to Bitcoin via OpenTimestamps. AI as building material, not arbiter. Sign up free → get an API key in 30 seconds.

The whole thing is 95% self-service — even the regulated- EU bank. The substrate's own outputs (L12 chain, runnable audit bundle, framework-mapped handoff packet) already produce what consultancies were charging €195k to deliver. Enterprise at €2,499/mo covers the lot. See the seven reliability pillars →

Quickstart · 5 min API reference + playground Live demo console Pricing The seven reliability pillars Three live reference deployments Full docs

Build against the substrate today. Get an API key, run the SDK locally, emit a real signed L12 chain — under the same Ed25519 trust anchor as the three live references. No NDA, no sales call.

Or · Enterprise tier · €2,499/mo · regulated-EU

Bank, hospital, govtech preparing for AI Act Annex III conformity? Enterprise unlocks framework templates + handoff packet generator today, with HSM hooks + on-prem option on the roadmap. Self-service · Stripe checkout · cancel anytime.

Start Enterprise →Public demo console

Different role? Different page:

Operators (VP Product · Platform)Developers (SDK)Regulators Investors·Live console Docs Pricing Licensing Feedback For Good

Live · the actual console surface

Not a screenshot. The real product.

Below is a live snapshot from the actual /console dashboard, rendered with the three reference deployments' real L12 chain data. Every status badge, every hash, every signature matches what an operator sees in production.

Promethean · console

● chain ok32 entries

Total entries

Schema-valid

81.3%

Reviewer queue

Trust anchor

Ed25519

Recent decisions · live

● 4 of 32

#12	paysafe	classifier	fallback	13e4274c…
#11	paysafe	classifier	fallback	e4e0f983…
#10	civicgate	router	fallback	c25291c4…
#10	cliniclens	extractor	fallback	fe107dea…

Trust anchor

y6F3rt10CEcSakCrnJIYkGymA66x3VXm…

Active chains

paysafe · 12cliniclens · 10civicgate · 10

Open the live console →See the full console (11 screens) →

The distinction that matters

Hardening is the floor. Demonstrable reliability is the bar.

Hardening · what most systems stop at

Six audit passes closed 40 findings.

Trust boundary. Operational envelope. Semantic integrity. Cross-module consistency. Federation game theory. An internal hammer pass. Every dimension we or external auditors could attack the system from. That gets you to correct today.

Reliability · what airtight requires

Seven mechanisms that prove it stays correct.

Tests catch silent code regressions (mutation). Canonical form is locked at byte level (golden chains). Invariants hold for thousands of random inputs (property fuzz). Verifiers always agree (differential). Live chains alert on drift (watch). Multi-language ports stay byte-identical (cross-lang). The chain's existence is third-party-attested in Bitcoin (OTS). Together they shift the bar from "trust us" to "verify us".

The seven pillars

Each pillar an independent check. Each falsifiable on its own.

Four pillars shipped in v1.1.7 (golden chains, property fuzz, differential verifier, watch daemon). Three closed in v1.2 (mutation testing, cross-language port, direct OTS anchor) plus operational controls documented in the runbook. All seven below — each with its own test artifact or command.

01v1.1.7

Golden chains

Canonical form locked at byte level. Any drift in canonicaliseEntry, JSON.stringify, or Ed25519 fails the build.

Falsifiable via

6 deterministic reference chains with pinned hashes · regenerable via GOLDEN_CAPTURE=1

02v1.1.7

Property-based fuzz

Invariants hold for thousands of inputs, not just hand-picked ones. Append-then-verify, tamper-detect, chain-extension monotonicity.

Falsifiable via

8 fast-check properties · 700+ random scenarios per CI run · seeded RNG for determinism

03v1.1.7

Differential verifier

The embedded plain-JS verifier and the TS verifier agree byte-for-byte on every input. The regulator-grade 50 KB verifier is independently testable.

Falsifiable via

4 tests · canonicaliseL12Entry extracted from embedded source and evaled against TS

04v1.1.7

Continuous-verify daemon

Live chain integrity issues are surfaced in real time. JSONL-per-check output, ingest-ready for Loki / Splunk / Datadog.

Falsifiable via

substrate:watch-runtime-ai · long-running watcher with per-chain reporting

05v1.2

Mutation testing

The test suite catches real code regressions, not just trivial ones. Below 75% kill rate fails CI.

Falsifiable via

stryker.conf.mjs · Vitest runner · thresholds 90/80/75 · npm run mutation-test

06v1.2

Cross-language port (Python)

JS-emitted and Python-emitted entries canonicalize byte-identically. Same SHA-256, same Ed25519 signature, same fixture.

Falsifiable via

runtime-ai-py/ · 8 fixture-driven differential tests · pytest

07v1.2

Direct L12 OpenTimestamps anchor

L12 chain HEAD exists at recorded wall-clock by third-party Bitcoin attestation — not just transitively via state.json.

Falsifiable via

runtime-ai-l12-anchor.ts · 12 mock-mode tests · npm run substrate:anchor-runtime-ai-head

The eighth control · operational, by design

Key ceremony (Shamir 3-of-5), HSM integration (PKCS#11, YubiHSM, AWS CloudHSM, Thales Luna), filesystem hardening (chattr +a, S3 Object Lock COMPLIANCE, auditd / Wazuh FIM), multi-process coordination, monitoring & alerting, disaster recovery, and the audit checklist for regulator certification — all documented in docs/OPERATIONS_RUNTIME_AI.md. Outside the code by design; load-bearing for the security posture.

The receipt chain

One signed entry per LLM call. Every field load-bearing.

L12 mirrors L10 (audit-receipt) and L11 (substrate-component) — a SHA-256 hash-chained, Ed25519-signed-per-entry log of every runtime AI decision a Promethean-emitted product makes. Each entry commits to the spec, the input (hashed for PII safety), the output (canonical hash), the model identity, latency, schema validity, reviewer verdict, fallback flag, and the previous head's hash.

Per-entry signing is structural, not preference. Runtime AI decisions have no underlying signed object the entry could delegate trust to. The signature lives on the entry itself.

One L12 entry · canonical form

{
  "id": 142,
  "recordedAtMs": 1747500000000,
  "recordedAtIso": "2026-05-17T18:40:00.000Z",
  "productId": "paysafe",
  "specId": "fraud-classifier",
  "specHash": "0a1b…",
  "inputHash": "1a2b…",
  "outputCanonicalHash": "2a3b…",
  "category": "classifier",
  "modelIdentity": {
    "provider": "anthropic",
    "model": "claude-sonnet-4-5-20250929",
    "version": "2026-05-01"
  },
  "latencyMs": 142,
  "schemaValid": true,
  "reviewerVerdict": null,
  "fallbackTriggered": false,
  "prevHash": "13e4274c…",
  "hash": "f8a91c2b…",
  "attestation": {
    "algorithm": "ed25519",
    "publicKey": "y6F3rt10…",
    "signature": "O2sfAG0a…",
    "signedAtIso": "…",
    "canonicalForm": "v1"
  }
}

The verifier surface

One command per claim. All seven independently runnable.

Verify a chain (Node, 50 KB stdlib only)

node verify.mjs <chain.jsonl>

Walks every entry, checks hash chain, verifies Ed25519 signatures. Exit 0 PASS / 2 FAIL. No npm install needed.

Verify with anchor surface

npm run substrate:verify-runtime-ai -- <chain>

Same plus surfaces latestAnchor, totalAnchorAttempts, currentHeadHasRealAnchor. Regulator-grade consumers require currentHeadHasRealAnchor=true.

Mutation testing (Stryker)

npm run mutation-test

Mutates the runtime-AI containment modules against their test suites. Thresholds 90/80/75. Below 75% kill rate fails CI.

Cross-language byte parity

pytest runtime-ai-py/tests/

8 fixture-driven differential tests: Python canonical bytes == JS bytes; Python signature == JS signature; round-trip verify across languages.

OpenTimestamps proof (Bitcoin)

ots verify <chain>.anchors/<headHash>.ots

Verifies the L12 HEAD existed at the recorded Bitcoin block height. Works against any Bitcoin full node offline. No Promethean trust required.

Continuous watch (live chains)

npm run substrate:watch-runtime-ai

One JSON object per chain per check on stdout. Pipe to Loki / Splunk / Datadog. Wire alerts on valid != true, anchor age > 6h, idsContiguous == false.

Three live references

Real chains, real signatures. Verifiable in 30 seconds.

PSD3 + DORA

paysafe

Fintech · fraud classifier

/paysafe-runtime-ai-receipts.jsonl

download · run node verify.mjs

HIPAA + MDR + AI Act

cliniclens

Healthcare · clinical-note structurer

/cliniclens-runtime-ai-receipts.jsonl

download · run node verify.mjs

eIDAS + GDPR Art. 22

civicgate

Govtech · message router

/civicgate-runtime-ai-receipts.jsonl

download · run node verify.mjs

Each reference deployment continues to verify under its original signatures byte-identically across every release. Backward compatibility is empirically demonstrated, not just claimed.

Cross-language byte parity · v1.2

One canonical form. Multiple runtimes.

Promethean emits products in TypeScript+Next, Python+FastAPI, and Rust+Axum. A Python-emitted product writing its own L12 entries MUST produce byte-identical canonical bytes and Ed25519 signatures to the JS-emitted equivalent — otherwise the regulator-grade verify.mjs would reject Python-written entries.

The runtime-ai-py package is the parity layer. Eight fixture-driven differential tests assert byte-equality of canonical bytes, SHA-256, and Ed25519 signature against a JS-authoritative fixture regenerable via npm run substrate:gen-cross-lang-fixture.

Parity invariants · load-bearing

JSON serialisation · Python uses json.dumps(separators=(',', ':'), ensure_ascii=False) to match JS JSON.stringify.
Integer-only numerics · id / recordedAtMs / latencyMs enforced as integers in both runtimes (Issue 31). Floats would diverge: JS prints "1", Python prints "1.0".
Insertion order · Python 3.7+ dict order matches V8 object iteration.
Ed25519 determinism · same key + same input produces byte-identical signature in every correct implementation (RFC 8032).

Direct L12 OpenTimestamps · v1.2

One sidecar entry · <chain>.ots-history.jsonl

{
  "id": 1,
  "headHash": "13e4274c…",
  "entryCount": 12,
  "anchoredAtIso": "2026-05-17T18:40:00.000Z",
  "anchoredAtMs": 1747500000000,
  "otsProofPath": ".anchors/13e4274c….ots",
  "mockMode": false,
  "status": "submitted-pending-bitcoin"
}

Closed-enum status: submitted-pending-bitcoin · mock-only · submission-failed · no-op-cooldown. Mock anchors NEVER satisfy currentHeadHasRealAnchor.

Bitcoin attestation, directly on the receipt chain. Not borrowed from another anchor.

L8 already anchors state.json to Bitcoin nightly, which covers L12 transitively. v1.2 adds direct 15-min Bitcoin-anchored OTS on the L12 HEAD itself (Vercel cron-tick cadence; daily anchor-upgrade cron promotes pending proofs to Bitcoin-confirmed).

anchorL12Head submits via the ots CLI when available, or writes a deterministic mock proof in mock mode (CI and air-gapped operators). Cron every 5 minutes is safe: the 60-second cooldown makes re-anchoring the same head a no-op.

After the calendar's Bitcoin commit (~1 block) and 6 confirmations (~1 hour), the .ots file is complete — verifiable offline against any Bitcoin full node, no Promethean trust required.

The operational boundary

What the code guarantees. What the operator carries.

Inside the code · enforced by the substrate

Canonical form, hash chain, Ed25519 signatures
Closed-enum schema enforcement at request time
Reviewer-queue gating + fallback execution
Append-time monotonicity + integer invariants
Tenant isolation (R4) + federation primitives (R5)
Mock-mode + real-mode OTS anchoring
All seven reliability mechanisms above

Operator-side · documented in OPERATIONS_RUNTIME_AI.md

Key ceremony (Ed25519 generation, Shamir 3-of-5 backup)
HSM integration (PKCS#11, YubiHSM, CloudHSM, Luna)
Filesystem hardening (chattr +a, S3 Object Lock, FIM)
Multi-process write coordination
Monitoring + alerting thresholds
Disaster recovery + compromise response
Regulator audit checklist (§10)

Start today

The architecture is ready. The references are live. The verifier is one command away.

Free Dev tier · 30s

Sign up free

Get an API key. Author your first RuntimeAISpec. Emit a real signed receipt chain under the same trust anchor as the three references. No credit card.

→

Source-available · auditable

Read every test, every ADR

50+ ADRs · 7,400+ tests across 223 files · v1.0 schema lock · Apache-2.0 verifier · source-available SDK (BSL-1.1) · public canonical form. Audit before you trust.

→

30 seconds · no install

Run node verify.mjs

Download any of the three reference receipt chains, run node verify.mjs. 150 lines of plain JS. Node 18+ stdlib only. No npm install.

→

The earlier substrate narrative — vision, Europe, system, build, evidence, regulators, roadmap, join — lives at /archive. Runtime-AI containment is the current product surface.

Cryptographically auditable AI for regulated products.Self-service from day one.

Not a screenshot. The real product.

Hardening is the floor. Demonstrable reliability is the bar.

Six audit passes closed 40 findings.

Seven mechanisms that prove it stays correct.

Each pillar an independent check. Each falsifiable on its own.

Golden chains

Property-based fuzz

Differential verifier

Continuous-verify daemon

Mutation testing

Cross-language port (Python)

Direct L12 OpenTimestamps anchor

One signed entry per LLM call. Every field load-bearing.

One command per claim. All seven independently runnable.

Real chains, real signatures. Verifiable in 30 seconds.

paysafe

cliniclens

civicgate

One canonical form. Multiple runtimes.

Bitcoin attestation, directly on the receipt chain. Not borrowed from another anchor.

What the code guarantees. What the operator carries.

The architecture is ready. The references are live. The verifier is one command away.

Sign up free

Read every test, every ADR

Run node verify.mjs

Cryptographically auditable AI for regulated products.
Self-service from day one.