AI decision verification for consequential agents
Hetu is an AI decision verification platform for enterprise agents in domains where a wrong autonomous action has financial, operational, regulatory, or safety consequences. Before an agent executes, Hetu checks whether the decision is supported by deterministic evidence, causal inference, or insufficient evidence — then confidence-scores and audits it.
Where this applies, and where it doesn't
A growing category of AI infrastructure now exists to make high-stakes AI trustworthy — some of it, elsewhere, by formalizing static rules (tax code, clinical guidelines, legal text) into machine-checkable logic and returning a formal proof. That's the right tool when the ground truth is a codified rule with exceptions.
Hetu solves a different version of the same problem: domains where the ground truth isn't a written rule at all — it's a causal pattern buried in operational data (why did this loan cohort underperform, why did this campaign's ROAS collapse) that has to be inferred, confidence-scored, and verified before an agent is allowed to act on it. Same discipline — prove it or refuse — different mechanism, because the underlying knowledge isn't formalizable text to begin with.
The signature
Pick a trigger. Watch it escalate through the tiers, hit the verification guard, and come out stamped — or stopped.
WHY1 → concentrated in a single intake vintage · WHY2 → upstream input quality 31% vs peer 58% in that vintage · WHY3 → two named sourcesNode names above are the neutral ones. In a deployment they are your metrics — the graph is configuration, not code. The tiers are not a fallback chain that degrades into guessing: each has a stopping criterion written before it runs, and Tier 3 is never permitted to state a cause at all.
Architecture
Every failure pattern your domain experts already understand, encoded as an explicit traversal. No statistics, no uncertainty. If the pattern matches, the answer is exact.
Traversals live in configuration. A new pattern is an insert, not a deployment.
When no rule fits, a fitted graph attributes the anomaly across candidate causes — with bootstrap confidence intervals and a residual, not a single number.
The confounder check runs first. If a known external event overlaps the window, attribution is suppressed rather than misassigned.
The last resort, and the most restricted. It receives a structured payload — never raw data, never an open prompt — and it is forbidden from stating a root cause.
Output is at most three ranked hypotheses, each with explicit confirming and falsifying criteria.
The verification guard
Every tier's output is checked before a human or an agent ever sees it. This is not a confidence score bolted on afterwards — it's a set of hard, auditable checks, and failing one means the conclusion is refused, not downgraded.
A wrong cause stated confidently is worse than two candidates and a test that separates them. The first sends an agent to act on a fiction. The second sends it to gather one more fact.
| Check | What it validates | On failure |
|---|---|---|
| Temporal ordering | The stated cause's timestamp precedes the stated effect's. Causes cannot postdate effects. | Refuse to render. Surface both timestamps. |
| Magnitude consistency | The claimed attribution, applied to the real baseline, produces an effect size within tolerance of the observed anomaly. | Refuse to render. Surface the mismatch. |
| Gate validity | The conclusion isn't sitting downstream of an active data-integrity fault on the same entity. | Suppress. Surface the upstream fault instead. |
| Sample-size floor | Every metric cited in the conclusion clears the minimum viable threshold. | Refuse to render. Name the thin metric. |
| Label match | The rendered language matches the confidence label exactly. | Block at narration. Regenerate with correct framing. |
AI Agent Governance
Hetu doesn't ask you to trust an agent on day one. It gives you an envelope — a bounded region of decision types where the system has demonstrated accuracy — and widens it only as outcomes come back. Everything outside stays gated.
A constraint framework is written for the use case: what counts as a fault, what gates what, what is never permitted. The cascade is enforced upstream of any action.
Before execution, the decision is simulated. If the tail outcome crosses a ruin threshold, or the situation is classified as chaotic, auto-execution is blocked and a human is called.
An immutable log of every decision generated, approved, deferred, executed and measured: who, when, what, why, and what happened. Regulators and post-mortems read the same file.
Measured outcomes update the causal weights and the confidence thresholds. Decision types that prove out move inside the envelope. Types that don't stay behind a gate.
Two rules survive calibration. Irreversible, fat-tailed decisions never auto-execute regardless of confidence score. And when realised outcomes fall outside the prior distribution, the regime-change detector narrows autonomy on its own — before you notice.
What you can buy
Self-serve or license. You integrate it; nobody from Hetu has to be in the room. If that's not where you are yet, see Consulting, Deployment, or Open Source instead.
Deterministic check, causal attribution, confidence label, audit log — on every call an agent makes before it executes.
Pre-seeded causal graph + gate set for one regulated decision type — lending, claims, trading, procurement.
Named-approver workflows, exportable immutable record, outcome tracking against actuals. The expansion tier.
Pricing
Verification Core is priced on volume because that's what it costs to run — every call touches a rule engine, a fitted causal model, and a guard check. Packs and Governance are licensed per decision type and per approver, because that's the unit your risk team actually budgets against.
Usage-based. Volume-tiered — price per decision drops as monthly verified volume rises. No seat fees.
One pack = one regulated decision type (lending, claims, trading, procurement), with its own pre-seeded graph and gate set.
Approval workflows, exportable immutable record, outcome tracking. Requires Verification Core already running.
Multiple packs, in-VPC or on-prem deployment, dedicated model-risk liaison — scoped per engagement.
Consulting, Deployment and Academy are priced separately — see Consulting or see Deployment — because they're delivered work, not metered usage. The Calibration Benchmark and the Decision Provenance Spec are free; see Open Source.
What we don't claim
Any vendor promising a language model that never confabulates is selling the thing they cannot deliver. The architectural answer isn't a better model — it's a smaller job for the model.
Design partners
We work with a small number of enterprise teams building agentic systems where a wrong action is expensive. We'll map your constraint framework, seed the causal graph with your experts, and show you the first refusal — which is usually the moment people understand what this is.
FAQ
AI decision verification checks whether an agent's proposed action is supported by deterministic evidence or causal inference before execution — and refuses when evidence is insufficient.
Observability and guardrails watch prompts, policies, and outputs. Hetu verifies the decision itself: root-cause claims, confidence labels, and an audit trail a risk committee can read.
LLMs learn statistical patterns in language rather than structural causal relationships in operational data. They can explain causality but cannot establish it with mathematical guarantees.
Database access improves retrieval, not reasoning. Causal inference, counterfactuals, confounder detection and uncertainty estimation require dedicated mathematical models.
No. Hetu verifies decisions; LLMs narrate verified outputs. The model never invents the finding.
Yes. Hetu is model-agnostic and integrates with leading foundation models as a narration layer only.
If you already ship agentic decisions, start with the platform or a Consulting engagement on one decision. If you want to measure calibration first, run the free tools on Open Source.