Every other system puts your data in the prompt.
Verificate puts your data in the argmax.
RAG makes the model read your data. Verificate makes your data write the answer. RAG decides at inference time, inside the model, token by token. Verificate decides at compile time, inside the data — inference just reads out the already-decided, receipted result.
The distribution that decides the answer is over your data — not the model's vocabulary.
An LLM writes every answer one token at a time, each token sampled from a probability distribution over its own vocabulary — the weights are the author, so the answer is always the model's guess. RAG, GraphRAG, fine-tuning and million-token context all do the same one thing: stuff your data into the prompt to bias that distribution — your data never leaves the context window, and the model still generates every fact. Verificate moves the decision off the model's vocabulary and onto your data: the answer is selected by an argmax over your own compiled facts before the first token is generated, and the model's softmax is demoted from choosing what is true to only choosing the words that narrate a result your data already decided.
RAG decides in the model
At inference time, token by token, over the model's vocabulary. Your data only biases the guess — so cost, quality and hallucination track the model, and you keep buying a bigger one.
Verificate decides in the data
At compile time, inside your data. Inference just reads out the already-decided, receipted result — the model cannot invent what your data did not compile. Your data is the asset, not the model.
The answer is decided before the question — then simply served.
Compile-Time Inference builds on the Verificate hybrid architecture: a cited EAV knowledge substrate for facts and a governed Decision Transformer policy for outcomes. See the architecture, layer by layer.
Ingest your facts and their outcomes
Your records, and what happened after them, are extracted into a cited entity–attribute–value substrate — source, provenance, licence and time attached to every record.
Order, rank and verify — at compile time
Facts and outcomes are ordered, ranked and verified into a decision substrate before any question is asked. The answers are decided here, once, against the record — not improvised later.
Serve the already-decided result
At inference the system returns the settled, receipt-backed result. The model only understands the question and phrases the answer — it does not reason over context, and it cannot invent what your data did not compile.
Compile the substrate. Then serve it. The model stays at the edge.
Compile-Time Inference is one accountable system built as a short pipeline: the substrate is compiled from your data, policy lives inside it as data, and answers or decisions are served from it — with the language model interpreting and narrating at the edge, never deciding.
Extraction — the substrate is compiled from your data
A proprietary process turns your records into typed, cited facts — entities, attributes, relationships and outcomes — with source, provenance and licence on each. An evidential-entropy entailment check gates what is admitted, so only supported facts enter the store.
An active substrate — policy lives as data
Facts and the policies that govern them are stored together as versioned, executable attributes. Change a goal or a threshold and every downstream value recomputes — cascading, versioned and reversible, with per-record lineage. It is a coordination layer, not passive memory.
Answer, decide, or decline
A fact-first router serves a covered question straight from the substrate — no model, no retrieval. Where the question is a decision, a Decision Transformer selects the action your records support by an argmax over the full projected state: same state, same action, every time, with per-decision lineage. When the store holds nothing, the system declines.
Served by HELIX 2 — the model narrates at the edge
HELIX 2, a bit-exact CPU inference engine, serves the settled result on infrastructure you control, with a confidence score for routing. The language model reads the question and phrases the answer — it never chooses the facts or the action.
Cite what the store holds, or decline — the shape behind the video (Hybrid-VLM) and genomics deployments. Here the model narrates a cited answer; there is no decision to make.
Pick the action the records support, deterministically — the shape behind legal and operational use cases, where the Decision Transformer owns the call and the model explains it.
The separation is the point: facts and policy live in a substrate you control, and the language model narrates — it does not decide. This does not make hallucination impossible; it makes every claim and every decision traceable to a layer you own. The same discipline runs as a separate product for AI-written software — Verificate Gate.
Over-intervention eliminated
A zero-shot frontier agent recommended action 43 percentage points more often than the correct institutional policy; a Decision Transformer trained on the institution's own data did not (EAV-DT study, OULAD). M
Decision flip rate
The trained policy produces the same action for the same complete state — an architectural property, measured at 0% flip rate. M
Learning from outcomes
On a real 251k-case procurement log (BPI-2019), the continually retrained policy beat a frozen one (p≈0.009); a label-permutation placebo collapsed the gain ~389×. M
Sources: EAV-DT paper (arXiv:2606.29280) · CORTEX paper (arXiv:2602.17691) · Research & reproduction
Every answer is verifiable — at every model tier.
In our model-invariance sweep, Compile-Time Inference returned 100% resolvable citations at every model tier — from the cheapest model to the largest. RAG and GraphRAG produced zero resolvable citations and fabricated, and only stopped fabricating when the model was a frontier tier you pay for. Run Verificate on a small, cheap model and you lose availability — never trust. M
| RAG / GraphRAG | Compile-Time Inference | |
|---|---|---|
| Where the answer is formed | At query time, by the model reasoning over retrieved text | At compile time, from your ordered, ranked, verified data |
| The model's job at inference | Do the thinking and write the answer | Understand the question and phrase the settled answer |
| Resolvable citations | Zero — and fabricated | 100% — at every model tier |
| Hallucination | Tracks the model; only a frontier tier reduces it | Structurally impossible — the gate fails closed |
| Run on a small, cheap model | Loses trust — it fabricates | Loses availability, never trust |
| What you must keep buying | A bigger model, every generation | Nothing — your data is the asset |
| Same question tomorrow | A fresh, non-deterministic answer | The same receipt-backed result |
Citation-validity result from the Verificate model-invariance sweep M · method and figures on Benchmarks and Research. We do not claim identical answers across models; the claim is that every answer is verifiable at every tier, and fabrication is structurally impossible.
Corroborated at national scale — Kevin
MKevin is a live compile-time instance over public Australian law. Under a preregistered Australian adaptation of Stanford's RegLab hallucination protocol (112 graph-verifiable questions, 42 false-premise traps), it produced zero fabricated citations and a 0.0% response-level hallucination rate (upper 95% bound 3.3%) — against 22.3% for the identical base model without the architecture, and 11.6% even with best-practice anti-hallucination prompting. Try the workbench.
Adversarial robustness
RAn adversarial jailbreak sweep — testing whether a hostile prompt can make the system fabricate — is in progress. Adversarial-robustness results forthcoming; we will publish the verdict rather than assert it.
Compile once from your record. Stop paying the frontier-model tax.
No frontier-model tax
Answer quality comes from your compiled, verified data — not the model tier you can afford. Run the cheapest model and you lose availability, never trust.
No re-migration each generation
Swap the language model without rebuilding your truth. The decision substrate is yours and outlives every model generation.
No model bias in the answer
The model phrases; it does not decide. Its priors cannot enter the outcome, because the outcome was compiled from your data before the model saw the question.
Full data sovereignty
The substrate is compiled and served on infrastructure you control. Your facts are the asset, and they never leave your company to reach us.
The verification layer and the engine underneath.
Verificate Gate
The verification layer that rejects any claim not backed by evidence — deterministic, in code, not a prompt. It fails closed, which is what makes fabrication structurally impossible. Also runs as a merge gate over AI-written software. Sold separately.
Verificate Helix
The inference engine that serves models on your own CPU, GPU, private-cloud or edge estate, with a 0–100% confidence score on every answer. The runtime that serves the compiled substrate — sold separately.
For decisions that must cite the governing record.
Regulated knowledge
Answers that must cite policy, legislation or contract — with licence and provenance attached.
Sovereign & on-prem
The substrate compiled and served on infrastructure you control, under licences you can honour.
Decision support
Operational decisions owned by a governed policy layer — the model narrates, it does not decide.
High-stakes advice
Where a fluent guess is worse than no answer, and every claim needs a resolvable source.
One platform. Move around it freely.
Compile-Time Inference
Verificate Gate
Verificate Helix
Replace RAG. Compile the answer.
Bring a knowledge domain or a decision process. We'll compile it into a cited decision substrate and show you verifiable answers at every model tier — on your own infrastructure.