Technology

The proof-native stack behind CueCrux

CueCrux is built for answers you can defend. Evidence is stored with provenance, receipts are signed, and an independent operator keeps the system honest. No trust falls required.

Minimal evidence sets (Quorum MiSES) replace citation spam.
Signed receipts make verified and audit answers replayable later.
Always-on monitoring flags drift, failure and tampering signals.

Request an invite Compare CueCrux Talk to us

Built for proof, not vibes

Evidence

Provenance, licence, integrity.

Receipts

Signed, replayable, inspectable.

Operator

Audits, drift, budgets.

A simple model

Question in. Evidence chosen. Receipt out.

Jobs wants one flow you can remember. Rory wants it to feel inevitable. This is that flow.

Illustration of the CueCrux flow from question to evidence set to receipt

1) Retrieve candidates

Hybrid retrieval pulls candidate artefacts from the evidence network, not a random pile of web pages.

2) Form Quorum (MiSES)

The system selects the smallest sufficient evidence set to support each claim, and checks contradictions.

3) Issue a receipt

Verified and audit modes produce a signed receipt so you can replay or defend the output later.

Core components

The stack, in plain English

Each plane has one job. Each job has receipts. That is the whole trick.

Perofant evidence database

Evidence is a first class object

Perofant stores artefacts with provenance and policy metadata, so answers are built on traceable inputs, not mystery paste.

Artefacts carry provenance, licence and integrity metadata (so you can audit what was used).
Hot, warm and cold tiers keep retrieval fast while receipts stay intact.
Quorum (MiSES) selects the minimal evidence set per answer, instead of dumping citations.
CROWN receipts capture the exact evidence and parameters used, so results are replayable.

See how receipts and MiSES work

Reasoning OS

Forward answers and reverse explanations

CueCrux is built for replay and inspection. You can see why an answer happened, and what would change it.

Forward path: retrieve, build Quorum (MiSES), answer within evidence limits (light, verified, audit).
Reverse path: “Why this?” views, diffs across time, and counterfactual replays.
Contradiction sweeps and retraction signals feed trust panels and operator dashboards.

Watch the short walkthrough

FactoryCrux ingestion

Policy-aware, cost-aware ingestion

FactoryCrux turns messy inputs into clean, licensed artefacts with a visible ingest trail. It is boring in the best way.

Respects robots, licences and rate limits, with metadata-only mode when terms are unclear.
Append-only ingest trail: fetch, parse, chunk, embed, commit.
Domain-aware embedding lanes keep query vectors aligned with chunk vectors.

See how ingest and verification are priced

WebCrux

The UI that makes proof usable

WebCrux is where the receipts become practical: modes, citations, timestamps, domain diversity and “Why trust this?” panels.

Mode badges make checking visible: light, verified, audit.
Evidence drawers let you open any claim and inspect what supports it.
Workspaces, history and saved proofs are tied back to MiSES and receipts.

Request an invite

WatchCrux and OpsCrux

An always-on operator, not wishful monitoring

The platform audits itself continuously. WatchCrux runs outside the main request path so drift and failures are hard to hide.

Health, readiness and metrics checks across planes, plus replay audits.
Budget control, SLOs, receipt health, backups, and cost visibility in OpsCrux.
Contract discipline: consistent /healthz and /metrics surfaces across services.

See live metrics and receipt health

SDKCrux

Typed rails for developers

A TypeScript-first integration surface so you can embed proofs in your product without building a parallel trust system.

Typed clients for answers, search, receipts, provenance verification, health and budgets.
Clear boundary: browsers talk to your BFF, not directly to Engine secrets.
Version and contract signalling via health endpoints so drift is detectable early.

Read the developer docs

FactoryCrux close-up

Ingestion that respects reality

Most systems ingest like a vacuum cleaner. CueCrux ingests like a librarian with a clipboard.

Licence and robots signals are captured as enforceable policy, not a footnote.
Domain-aware embedding lanes keep retrieval honest and debuggable.
Users can request site ingest with upfront cost quotes in £ and Crux credits.

Illustration of policy-aware ingestion from sources into indexed artefacts

Illustration of monitoring and audit oversight with health signals and receipts

Always-on operator

Trust is maintained, not declared

WatchCrux and OpsCrux exist for the same reason aircraft have black boxes. When things get weird, you want evidence, not explanations.

Independent audits and replays outside the main API lifecycle.
Drift detection so you can prove which code and models produced an answer.
Budget controls so verification depth is explicit and predictable.

See metrics See costs

Deployment and economics

Scale proof without losing control

Whether you run public workloads or regulated workloads, the same rules apply: receipts, boundaries, and measurable verification.

Illustration of isolated tenant stacks with federated proof verification

Crux Economy

Credits tied to real verification work

Crux is an internal credit system that meters compute and rewards useful evidence, without turning your product into a token circus.

Spend credits on deeper verification (verified and audit), priority compute and hot storage.
Earn credits when your uploads or links get reused in MiSES evidence sets.
Non-transferable and ledgered. Participation, not speculation.

See pricing and credits

Private Stack

Tenant-isolated planes for sensitive work

For regulated or confidential data, Private Stack isolates the full pipeline per tenant and still supports verifiable proofs.

Per-tenant segmentation and service isolation with strict boundaries.
Extensions add private agents and workflows without forking core services.
Federated proofs: verify receipts by hash without moving raw content.

Talk to us about Private Stack

Security and integrity

Trust by design, safety in depth

Keys, receipts and provenance are treated like production-grade infrastructure, not a slide deck feature.

Vault-backed secrets and signing, with short-lived auth boundaries.
Receipts are append-only: history is superseded, not quietly rewritten.
Ingestion gates and anti-manipulation controls are enforced as policy.

How CueCrux hardens trust

Want proof inside your product?

Embed “Why trust this?” panels, receipts, and citations in your workflows, or deploy Private Stack for regulated data. Same rails, different envelope.

Request an invite Talk to us Compare CueCrux