Private AI inference with
confidence-aware control.
Run capable models on infrastructure you control. Verificate Inference Engine uses the HELIX v1.8 runtime to serve CPU, GPU, private-cloud, on-premises and edge workloads with a 0–100% confidence score your application can use to deliver, confirm, escalate, or block. HELIX is an inference engine, not a model — it works with any open model you choose.
The percentage is honest: an 80 score is right about 80% of the time — usually within ~2.6 points of reality, vs ~30 when the model rates itself · under 1% CPU overhead, ~0% on GPU M · your app decides; the engine does not rewrite answers
HELIX is the technology inside — not a competing model.
Not ChatGPT. Not Claude. Not Llama. HELIX is Verificate's inference runtime — the software that runs the open model you choose on the machines you control, and attaches a trustworthy confidence score to every answer while it does. It is model-agnostic by design: our lead production models today are GPT-OSS 120B for text and Qwen3-VL 4B for vision, and the same engine serves Llama, Granite, Gemma, Qwen and other open families — dense or mixture-of-experts.
Cloud AI APIs
SaaS APIs. You send a question to their service. Easy to start — your prompts and data leave your company.
Open models
A trained AI you can license or download and keep. That file is the “brain.” It does not answer anyone until something runs it.
Verificate Inference Engine
A containerized image you run wherever you need inference — cloud, on-premises, or edge. Runs your model, scores every answer. Your data never leaves your company to reach us.
Picture it this way. ChatGPT and Claude are restaurants — you visit, they cook, your order leaves the building. An open model is the recipe. The Inference Engine is kitchen equipment we deliver as an image — you install it in your building. Answers stay home. Every plate gets a confidence score.
v1.8 puts the confidence runtime on the measured v1.7 serving spine.
The serving numbers below were audited on v1.7. v1.8 is the current generation: the same engine, with the confidence surface extended across inputs and model families — described here at the level of what you get, with the evidence trail on the claims page.
Confidence beyond text
v1.8 scores vision-model responses on the same 0–100% surface as text — image and document understanding with a signal your application can route on. Lead vision model: Qwen3-VL 4B. M Audio is on the roadmap. R
Large sparse models, first-class
Mixture-of-experts families are served with the same confidence surface — including GPT-OSS 120B, our lead text model, on GPU and CPU-only deployments alike. M
Swap models, keep the contract
The engine is tuned per model family, but your application contract never changes: the same OpenAI-compatible API and the same confidence field, whichever open model you run today or switch to next year.
Your data never leaves
your company.
Cloud AI APIs put someone else's service in the path of every answer. The Inference Engine is the opposite: we license a containerized image you run wherever you need inference — Kubernetes, OpenShift, VM, cloud account, or air-gapped network. There is no Verificate SaaS in the path of your production answers.
The live demo is hosted so you can try the engine. Production is always your image, in your environment.
- Your Kubernetes or OpenShift cluster
- Your cloud account / customer partition (AWS, Azure, GCP)
- A bare VM — on-prem or private cloud
- Fully air-gapped, zero outbound telemetry
Escalation only works if the cheap model knows when it is guessing.
Many teams start with a small model and escalate to a frontier model when the job gets hard. The silent failure: the cheap model is confident and wrong — so it never escalates, and the premium tier never sees the risk.
Confident wrong never escalates
Self-ratings, vibes, and “sounds unsure” miss fluent fabrications. Wrong facts and tool steps get written into the agent trail. By the time a premium model is called, the context looks rich — and poisoned. Risk sat on the cheapest tier the whole time.
A trustworthy score at every stage
The engine attaches a calibrated 0–100% confidence score to every response — cheap, mid, or premium. High → deliver. Mid → confirm or escalate. Low → escalate or block. You escalate on risk, not vibes — so the cascade does what the architecture promised.
We measure residual risk at a review budget — we do not claim AI never errs. Numbers on Benchmarks M
Different failure modes. One score your systems can use.
Simple keyword filters miss confident fabrications — nearly half of real failures still look “sure.” The engine's score is built from multiple signals, not fluency alone.
Guessing under uncertainty
The model does not know — and invents a fluent answer anyway. On the page it still looks like normal prose.
Confident fabrication
Sounds sure — invented names, facts, or citations. Asking the model to check itself often still says “fine.”
Internal disagreement
Parts of the model disagree before the final wording. Judging only the finished text misses the split.
Ignoring the source material
Skips the document or tool result and fills gaps from memory — even while citing sources.
Out of date, still fluent
RWas true once; no longer (prices, roles, “latest”). Roadmap coverage until measurements lock.
Wrong about an image or audio
Describes what is not in the file. Text-only checks do not catch it.
One score leaders understand
Risk is assessed as the answer is produced, then summarised as a 0–100% confidence score your teams can act on.
A score — not a silent rewrite
The engine does not quietly edit answers behind the scenes. It scores risk; your application decides what happens next.
You set the rules
Deliver when high. Confirm or escalate when uncertain. Block when too low.
Light enough to leave on
Confidence scoring at under 1% compute cost — near-zero added cost on GPU in measured runs.
Faster inference — including on smaller infrastructure.
The engine is built to run where the work already lives: full GPU deployments when you need them, and first-class CPU, edge, and IoT paths when smaller infrastructure is the right call — without making “cheap hardware” the whole story.
An OpenAI-compatible endpoint — on your machines.
After you deploy the image, point existing SDKs at your endpoint — not a Verificate cloud. /v1/chat/completions, /v1/models, streaming, schema-valid JSON — plus a confidence score your application can route on.
- OpenAI-compatible /v1 chat + models API
- Server-sent-events streaming
- Grammar-masked JSON schema mode
- Per-response confidence for deliver / confirm / block
curl https://<your-inference-pod>/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "openai/gpt-oss-120b",
"messages": [{"role":"user","content":"Extract as JSON..."}],
"response_format": {"type": "json_object"},
"stream": true
}'Speed you can measure — trust is the new column.
Serving latency on official vLLM-project GuideLLM harness, identical AMD EPYC 9254 (Genoa), 32K context. Engine benchmarks elsewhere stop at tok/s — the Inference Engine adds the confidence surface.
| System | Concurrency | TTFT p50 | Valid JSON | Tokens / request |
|---|---|---|---|---|
| Verificate HELIX v1.7 | c=1 | 940 ms | 100% | ~85 (complete) |
| Verificate HELIX v1.7 | c=4 | 2,469 ms | 100% | ~87 (complete) |
| Stock Ollama (32K) | c=1 | 8,416 ms | ~84% | ~16 (fragment) |
| Stock Ollama (32K) | c=4 | 31,816 ms | ~84% | ~16 (fragment) |
HELIX v1.7 Build #58 serving numbers · v1.8 adds the confidence runtime on this spine M · see Benchmarks and Research
Built as an inference engine — not a chatbot wrapper.
Deterministic & auditable
Serve single-slot with a pinned seed — or on CPU — and every run is byte-identical: the same input returns the same answer, so a decision is reproducible and audit-ready. Shared, batched GPU inference cannot promise this, because a result depends on whatever other requests share the batch.
Isolated per workflow
Run a dedicated reasoner per workflow instead of many tenants contending for one shared pod — no noisy-neighbour batching, no cross-workflow coupling, predictable latency each workflow owns.
Tuned to the model you run
Serving paths built for the model you deploy — CPU, GPU or edge — not a generic runtime that leaves accuracy and speed on the table.
Valid JSON, every time
Responses constrained to your schema so integrations do not break on malformed output — even under load.
Throughput mode when you want it
Warm, continuously-batched request slots keep first-token latency steady for interactive traffic — switch to the deterministic path for gate, compliance and audit runs.
OpenAI-compatible API
Point existing SDKs at your deployment — familiar chat and models endpoints inside your environment.
Lead production models today: GPT-OSS 120B (text, mixture-of-experts) and Qwen3-VL 4B (vision). The engine is model-agnostic and tuned per model family — the same runtime serves Llama, Granite, Gemma, Qwen and other open models. Deployed in production at UNSW.
Benchmark your infrastructure.
Try the public demo, then talk to an inference specialist about running the engine on your own cloud, on-premises, or edge estate. Production answers stay in your company.