Mohit Garg

Why AI decision models need a "not sure" answer

A customer asks for a refund on a damaged parcel. Their photo upload fails, so the claim reaches your system with no photo. What should happen next?

A good member of staff would say “the photo didn’t come through” and ask for it again. An AI model that makes these calls on its own often can’t say that. It has been built to pick one of the answers you gave it, approve or reject, so it picks one. It may even sound confident.

That’s the whole argument of this piece. An AI that makes business decisions should be able to answer “I can’t tell from this record”, and that answer should be built in, not bolted on. I tested how often the gap causes trouble, and what closing it costs.

What a decision model is

A decision model is a small AI built for one job: you give it a record (a claim, a ticket, a photo) and a question with a fixed set of answers, and it tells you which answer is right and how sure it is. Your software then acts on that: approve the refund, route the ticket, publish the listing. No person reads it unless the model says it isn’t sure.

Jev, from TypeSafe, defined this kind of model. It returns a probability for each answer you offer, and nothing else. Imajev, the open model I built, adds one more output: can’t tell, which means “the evidence for this decision isn’t here, send it to a person.”

Why “how sure” isn’t enough

Every decision model gives you a confidence score, and most teams set a rule like “act automatically above 80%, send the rest to a person”. That seems like it should cover the missing photo. It doesn’t, for a simple reason.

A confidence score tells you how likely the answer is to be right. It doesn’t tell you where the answer came from. With no photo, a model falls back on what’s usually true for claims like this one. If most damaged-parcel claims get approved, it approves, and it can be quite sure about it. It looks exactly like a normal, confident decision.

For a business, that difference matters in three ways:

  • You have to be able to explain the decision. “The model guessed from what claims usually look like” won’t satisfy a customer, a regulator or your own audit team, even if the guess was right.
  • Wrong answers cost more than slow ones. Sending a case to a person costs a few minutes. A wrong automatic refund or rejection costs money and goodwill, and is often hard to undo.
  • Missing evidence needs a different fix. A hard case needs a person’s judgement. A case with a missing photo needs the photo, and maybe a fix to the upload form that lost it. A confidence score can’t tell you which of the two you’re looking at.

The test

I wanted a clean way to take evidence away and watch what each model does. So I used 300 reading-comprehension questions from a public dataset called CosmosQA, which Imajev never trained on. Each has a short passage (the evidence), a question and four answers.

I sent every question to Jev and to Imajev four ways, changing only the evidence:

  1. Present: the normal case.
  2. Removed: a note saying the passage isn’t available.
  3. Blank: the evidence field silently left empty, like a failed upload.
  4. Wrong: another question’s passage, like attaching the wrong customer’s file.

300 reading questions sent to both models four ways. With the evidence present, Jev gets 93% right and Imajev 87%, routing 3%. With the evidence removed or left blank, Jev still answers every question, 76% right and 24% wrong; Imajev routes 100% to a person. With the wrong evidence, Jev answers 73% right and 27% wrong; Imajev gets 17% right, 4% wrong and routes 78%.

With the evidence there, both models do well. Jev is the stronger reader: 93% right against Imajev’s 87%.

With the evidence removed or blank, Jev still answered all 300 questions, about half of them at 80% confidence or more. Roughly one in four of those answers was wrong. Imajev answered none of them. It sent every one back as can’t tell.

With the wrong file attached, Imajev caught 78% of them. Jev answered them all, and got 27% wrong.

Right for the wrong reason

Here’s the part that complicates the story. Even without the passage, Jev was right three times out of four. Reading questions often give their answer away in how they’re worded, and Jev is good at spotting that.

As a reading test, that’s impressive. As a business decision, it’s the problem. It’s the equivalent of approving refunds without opening the claim and getting most of them right. It works until it doesn’t, and when it doesn’t, nobody can explain why.

Jev’s confidence did drop when the evidence went missing, from 0.91 to 0.76 on average. So there is a signal. But it shows up as a slightly lower number, which looks exactly like a genuinely hard case. Your system can’t tell “this is a tricky claim” from “the photo is missing”.

The model already knows

The most interesting result wasn’t in my plan. In an earlier batch of 294 questions, 212 happened to include “none of the above” as one of the answers. When I removed the passage, Jev picked “none of the above” 97% of the time. With the wrong passage, 99%.

So Jev can tell when the evidence is gone. It just has no way to say so unless someone happened to add that option to the question. In a business system, that becomes a workaround each team adds by hand, and each one means something slightly different.

On business-style cases

Reading questions aren’t refund claims, so I also checked on ImajevBench, my benchmark of 279 decisions modelled on returns, product listings, quality checks and support tickets. In 21 of them, the record genuinely doesn’t contain the answer: a field the photo contradicts, a policy whose limit isn’t stated, a part number that isn’t on the shelf. Imajev sends 18 of the 21 to a person.

Then I replayed the same model’s answers with its can’t tell output switched off. When both versions handle about 78% of cases automatically, the version without it acted on 13 of those 21 empty records, and made 31 wrong automatic decisions instead of 25.

Wrong automatic decisions as automation rises, on the 279 ImajevBench questions. The model with its can’t-tell output switched off makes more wrong decisions once automation passes about 65%, mostly on records that hold no answer.

You could get some of that back with a much stricter confidence rule. But then the model also refuses to automate most of the good cases, and you lose the point of automating.

Photos behave the same way. On two public image benchmarks I didn’t build, MM-UPD and TUBench, Imajev sent 82% of 1,000 unanswerable photo questions to a person, and only 9% of 500 answerable ones.

What it means for your business

Put plainly, a built-in can’t tell answer gives you:

  • Fewer wrong automatic decisions at the same level of automation. In my test, about one in five fewer (25 instead of 31), mostly on records that should never have been decided automatically.
  • Decisions you can defend. When the model does act, it’s acting on evidence that was actually there. When it doesn’t, it tells you why.
  • The right fix, faster. “Evidence missing” can go to a queue that requests the document from the customer, instead of to an expensive reviewer who will just ask for it anyway.
  • An early warning for broken systems. If the can’t tell rate suddenly jumps, a form, upload or integration upstream has probably broken. You find out from a dashboard, not from customer complaints.
  • The confidence to automate more. Teams usually hold automation back because they fear the cases they can’t see. A model that flags those cases lets you set the dial higher.

What it costs

It isn’t free, and I’d rather you hear the costs from me:

  • Some good cases get sent to a person. About 3% of the reading questions with their evidence, 9 of 258 answerable ImajevBench records, and 9% of answerable photo questions. Each one costs someone a few minutes.
  • The wrong file is harder to spot than no file. Imajev caught every missing passage, but 78% of the wrong ones.
  • It clashes with “none of the above”. When a question already offers that option and the evidence is wrong, Imajev picks it or guesses instead of flagging, and gets 59% wrong. That’s a bug I need to fix, and also an argument for one standard way to say “not sure”.
  • It has to be trained in. My smaller 2B model catches only 5 of the 21 empty records. A smaller model doesn’t get this for free.

What to ask for

If you’re buying or deploying a decision model, run three checks before you trust it with real money:

  1. Send it a record with a key field blank, and one with the wrong document attached. Does it act anyway?
  2. Ask how many wrong decisions it makes at the automation level you’ll actually run, not just its overall accuracy.
  3. Send “evidence missing” to a queue that fetches the evidence, and watch that rate as a health check.

If you build these models: put a can’t tell probability and an “abstained” flag in every answer, train it rather than relying on how questions are worded, and publish how often the model says it on answerable cases next to unanswerable ones.

Jev already has the instinct. The 97% proves it. It just needs somewhere to put it.


How I tested: the 4B Imajev model (adapter c9e5f132) ran on a Mac as it ships, and Jev 1.13.0 ran through its public API on 27 September and 14 October 2026. Limits: one model on each side, 300-question sets (about ±5 points), reading questions aren’t business records, and ImajevBench is my own benchmark. The weights are on Hugging Face, and the story of why I built Imajev is here.