Hetu / Industries / Commerce & growth platforms
Decision verification for commerce & growth agents
Hetu verifies budget, pricing, and lifecycle agent decisions before they execute — so a confidently wrong attribution cannot move spend unchecked. For CTOs and VPs of engineering and product building autonomous agents on commerce and marketing data, where the failure mode isn't the agent being wrong — it's nobody finding out until the spend already happened.
The postmortem
The agent cut spend on the adset that was actually working, because it attributed a seasonal dip to creative fatigue. It sounded completely reasonable. It wrote a clean paragraph. It was also confidently wrong, and it moved ₹40,000 a day for five days before anyone looked.
Your engineers ask the obvious question: how do we stop this happening again? And the honest answer with a general-purpose LLM is: you can't, structurally — you can only add more prompt engineering on top of a component whose job was never to compute anything correctly in the first place.
Meanwhile every customer contract you're signing says "AI-powered decisions" and every legal review asks what happens when the AI is wrong. You don't have a good answer. You have a good demo.
Why this is an engineering problem, not a prompting problem
The instinct is to fix this with a better model or a longer system prompt. Both are treating a systems-design problem as a model-quality problem. The fix is architectural: stop asking the model to compute, and it stops being able to compute wrong.
What you get to build on
Root cause and attribution come from a deterministic rule tree and a fitted causal model. The LLM receives the verified output and writes a sentence about it — it cannot introduce a number or a cause that wasn't in that payload, and is rejected if it tries.
You define which decision types can execute unsupervised from day one — typically none. As measured outcomes accumulate per type, the envelope widens. You ship a chatbot on day one and an agent within a quarter, provably.
A rule miss escalates to the causal model. A causal miss escalates to a constrained hypothesis generator that is forbidden from naming a cause. If nothing clears the bar, the system returns "insufficient context," and your agent has a defined, testable state to handle instead of an undefined one.
Tier 1 is a traversal in configuration — you can unit test it. Tier 2's stopping criteria (explained variance, interval overlap) are numeric thresholds you can assert on. Only Tier 3 touches a language model, and its output is schema-constrained and guard-checked before anything downstream sees it.
Confirmed, high, medium, or hypothesis — requires input. That label is the answer to "what happens when the AI is wrong": the system already told you how much to trust it before you acted on it.
The causal graph, the WHY traversals and the hard gates are configuration. Onboarding a new customer or a new decision type is an edit to a table, reviewed by the domain expert who knows the failure pattern — not a new model or a new codebase.
Proof, not a spec
Niti AI runs its entire budget-allocation and creative-fatigue product on this engine. Every recommendation it makes — cut this adset, raise this bid, retire this creative — passes through the same three tiers and the same guard before it reaches a human's approval queue.
| Trigger | Path | Label |
|---|---|---|
| Known fatigue pattern, matches traversal | Tier 1 only | Confirmed |
| Novel throughput anomaly, no rule match | Tier 1 → Tier 2 | High |
| Anomaly overlaps an undeclared platform change | Tier 1 → 2 → 3 | Refused |
Row three is a real state your agent needs to handle gracefully — and with this architecture, it's a state your system produces on purpose, not a failure mode you discover in production.
Integration
You keep your product surface, your users, your brand. Hetu is the layer that decides what your agent is allowed to say it knows.
FAQ
Budget reallocation, pricing and discount actions, and lifecycle interventions — any decision where a wrong causal claim moves money before a human notices.
No. Hetu sits under your product as a verification layer. You keep the surface, users, and brand; Hetu decides what the agent is allowed to claim it knows.
Niti AI is the reference production deployment — its budget-allocation product runs on this engine today.
Yes. Most teams prove one decision in shadow via Consulting, then expand the same graph and gates on the platform.
Explore
Design partners
We work with a small number of product and engineering teams building autonomous commerce and growth agents. We'll help you encode the traversal your best analyst already runs in their head, wire up the causal graph, and show you the engine refuse for the first time — which is usually the point your team stops worrying about the demo and starts trusting the system.