Aequitas AI
The AI that abstains instead of bluffing
Start new thread

Aequitas AI - The AI that abstains instead of bluffing

by•
Every other AI always answers, even when it is guessing. Aequitas debates a hard question from many angles, formally verifies the reasoning with a math proof engine (not another AI), and certifies a verdict only when it can prove it is grounded. When it cannot, it says so.

Add a comment

Replies

Best
Maker
📌
Hi Product Hunt. I am Ruthvik, and I built Aequitas on my own. The inspiration was an uncomfortable observation: every AI system today is a language model checking a language model. You can stack as many critics and review passes as you like, but if every part of the stack is a language model, then nothing in it is incapable of hallucinating agreement. There is no point where something the AI cannot fake checks the reasoning. The other half of the problem is that every AI product always answers. Always. Even when it is far out of its depth. That is not something you fix with a better prompt. It is structural. Now think about who needs AI the most. A lawyer. A risk team. A regulator. A board. These people do not need an answer. They need an answer they can defend to somebody who is allowed to say no. For them, a fluent and confident wrong answer is worse than no answer at all, because they will act on it and then have to explain themselves. So Aequitas is built around the opposite instinct. It takes a hard question, debates it from multiple perspectives, then puts the reasoning through a formal proof engine, a mathematical solver rather than another AI grading the first. An independent adversarial audit tries to break the result. It also maps the cases where two goals in a decision genuinely cannot both hold, instead of papering over a real trade off with a fake consensus. Then a final deterministic gate, with no AI in it at all, decides whether the verdict earned the right to be called certified. When the reasoning cannot be shown to be grounded, Aequitas says so rather than quietly stamping it certified. Here is how the approach evolved, and it is the part I did not see coming. I set out to build the most rigorous answer machine I could. Then I found something in my own system that changed the project. A key internal model could quietly fall back to a weaker version, and the final report would still say "certified." Nothing was structurally stopping it. The output looked identical either way. That reframed everything. A system that cannot check its own machinery has no business certifying anything, because certifying a degraded run is a lie you do not even know you are telling. So I built a gate whose entire job is to block my own system. Aequitas now checks the health of every load bearing component on each run, and refuses to certify if any of them ran weakened. The same instinct spread. My reliability score used to look like a calibrated probability when it was really just a formula output, so I made it label itself uncalibrated instead of faking precision I had not earned. My fast screening tier is now code blocked from ever claiming certification, so a shallow pass can never dress itself up as a deep one. Where it actually stands today, precisely, because that precision is the product. Live on every certified analysis: the multi perspective deliberation, formal verification of every claim, the independent adversarial audit, the grounding check with its decision recorded and disclosed on every run, the machinery health attestation (that one already blocks certification outright), and honest tiers. Rolling out: turning the grounding gate's disclosure into a hard automatic block, which is a single switch I flip once the confidence calibration is fitted on real outcomes, plus independently re verifiable proof certificates and calibrated confidence scores. I would rather tell you exactly which is which than let you assume. One thing I want to be straight about. Formally verifying AI output is not new, and at least one major cloud provider does it well. What I have not found anywhere is a system that makes the certify or abstain call its own verdict on an open ended question, and that refuses to certify when its own machinery is degraded. My ask: give it a genuinely hard question from your own field and watch what it does. Honestly, I would love it if you caught it abstaining. That is the product working, not failing. Happy to take any question, especially the skeptical ones.

Asking it a tricky ethics question actually returned "I cannot verify this" instead of a confident guess, which was refreshingly honest. The formal proof step is a neat touch.

Maker

 Thanks, really glad it landed that way the honest "I can't verify this" is by design, not a limitation. Small caveat I can't resist: the formal step checks that the reasoning is consistent and re-checkable rather than proving the answer "true" but that's precisely what lets it abstain honestly instead of guessing. Curious what question you threw at it, if you're up for sharing?

How does the formal verification step actually work under the hood, and does it require domain-specific setup or can it handle general reasoning questions right out of the box?

Maker

 Great question, and it is the one I most want to answer precisely.

Under the hood, the debate does not stay as prose. The system compiles the arguments into a structured logical form: the individual claims, and how they support or contradict each other, laid out as something a machine can actually reason over. Then a formal proof engine, the class of mathematical logic solver used to verify software and hardware, checks that structure for properties a language model cannot reliably self-assess. Can all these claims be true at the same time, or is there a hidden contradiction. Which arguments are defeated by stronger counterarguments. Where two goals in the decision are genuinely irreconcilable rather than just in tension. That check is deterministic. Same inputs, same result, every time. And no language model runs inside it, which is the entire point: the thing doing the checking cannot hallucinate the way the thing being checked can.

On your second question, and this is the part I am proudest of: no domain-specific setup. You do not author a policy, a rulebook, or a schema. You ask a hard question in plain language and it works out of the box. That is a deliberate contrast with the formal-verification tools that already exist, which check a response against rules you have to write in advance. The hard part we automate is the formalization itself, turning your messy natural-language question into the structured form the solver can check.

The honest limit, because you asked a real question and deserve a real answer: turning language into logic is genuinely hard, and that translation step does use models. So when a question cannot be cleanly formalized, or the evidence does not actually support grounding, the system abstains instead of forcing a false "certified." The abstention is not a failure mode bolted on the side. It is the same discipline pointed at its own weakest step.

finally, an ai that admits when it doesn't know instead of confidently making stuff up. the math proof engine angle is genuinely different from the usual "trust me bro" approach.

Maker

 Thank you, that is exactly the line I care about.

One thing I stay disciplined about even when someone is being kind: formally verifying AI output is not something I invented, a major cloud provider ships it too. What I have not seen anywhere else is making the certify-or-abstain call the product's own verdict on an open-ended question, and refusing to certify when the system's own machinery is running in a degraded state.

The "admits when it does not know" part is the piece I most want to get right. So if you ever catch it answering when it should have abstained, that is the bug report I want most.

How do you handle situations where the math proof engine can't verify something but the debate among perspectives still produces a strong consensus, do you just refuse to answer then?

Maker

 No, and this is the most important distinction in the whole product, so thank you for asking it precisely.

First, separate two things that both look like "the proof engine couldn't verify it," because they get handled very differently.

One: the engine finds an actual contradiction. Then the consensus is the problem, not the answer. A confident, unanimous agreement that is internally inconsistent is exactly the failure mode the whole system exists to catch, and it says so loudly.

Two, and this is your case: the engine simply cannot reduce the question to a clean formal check. No proof either way. Here the debate's consensus still stands as the verdict. You get the full analysis, the reasoning, and the conclusion. Nothing is thrown away. What changes is the label. It does not earn the top certified stamp, and it gets an honestly lower reliability label instead, one that says in effect "strong deliberative consensus, not formally proven."

The reason it works this way is the entire thesis of the product: consensus is not proof. A room full of language models agreeing can be confidently, unanimously wrong. That is the specific way sophisticated AI systems fail, and it is why I refuse to let debate agreement alone earn certification. Agreement is a real signal, and it does raise the confidence label. It just cannot, by itself, buy the word certified.

So abstaining never means refusing to give you anything. It means refusing to call something certified when it has not earned that word. The output is not binary. It is a graded, honest confidence, and the strong-consensus-without-proof case lands exactly where it should: useful, believable, and clearly marked as not carrying a formal guarantee. You decide how much to lean on it, with the truth about its backing in front of you, instead of a certified stamp it did not deserve.