What does a model owe you when it is not sure?

Every accessibility tool I've built generates text, and I'd never thought of that as a design choice.

In a machine shop there's a tool called a go/no-go gauge. It has two ends, and one end should slide over the part while the other should not. All it reports is whether the part fits.

It can't be persuasive about a part that is out of tolerance. My tools can (fluently).

The failure I keep writing about on this blog always looks the same. A model reaches for a fact it doesn't have, and returns a string.

It might be an aria-label from a guess, a contrast ratio that is plausible and wrong, or a spacing token that never existed in the system.

The trouble is that a string carries no signal about how sure the thing that wrote it was. "4.6:1" looks the same whether it was retrieved or invented.

So it ships, and the person who discovers the difference is the person who can't check.

That might be someone with low vision reading helper text that was never graded, or a screen reader user told that a control is something it isn't.

This model gives up writing

On 15 September, TypeSafe AI came out of stealth with Jev (opens in a new tab), which they call a System One model. The part that interests me is a constraint and not a capability, which is that Jev gives up string generation entirely.

You hand it some state and a typed question. It returns one of the options you supplied, with a probability distribution and a confidence score.

There are three primitives (opens in a new tab). Choice picks from a list of up to 255 options. Score rates the state against a rubric. Noul answers whether a statement is true, as a number between zero and one.

It can't return something outside the set you gave it, or something malformed. The probabilities are calibrated, which is meant to mean that a low number is honest about being low.

None of that makes the model right. It turns the model's uncertainty into a value my own code can read, which is a different property, and for our work it's the one worth more.

Accessibility failures are the quiet ones

Our failures are the quiet ones. A wrong contrast value doesn't throw an error. A missing focus style doesn't fail a test, and an invented accessible name doesn't look different from a researched one.

Nothing in a normal pipeline stops on any of them, which is why they reach people instead of reviewers.

Now ask the same questions as typed ones. "Which success criterion does this failure fall under?" becomes a Choice across the 87 in WCAG 2.2.

"Does this accessible name describe what the control actually does?" becomes a Noul. "Does this alt text narrate, or does it merely label?" becomes a Score against a rubric.

Every one of those comes back with a number attached, so a 0.51 is a flag on a specific line. Today that same uncertainty arrives as a fluent sentence with nothing on it.

I'd take a check that can say it isn't sure over a check that is usually right, because the first one tells me where to look.

Some things it does not fix, and some I have not measured

Jev can't write the alt text. That's string generation, the thing it gave up, so the generator that invents is still in the pipeline. What's new is that something downstream can grade its output and hand back a number.

The claims are also young, and TypeSafe are more careful about this than the coverage has been. They describe the hallucination rate as zero, and they say plainly that the figure is theoretical and not empirical.

They note that the tested workflows were built by their own capabilities team, and that some bias could exist. They have not published benchmarks.

I haven't run it against anything on this site, so I've measured nothing here. This post is a reading of a design decision and not a report on a run. Whether Jev makes any interface more usable, I don't know.

I'm confident about the approach, not the vendor. Failures that arrive as numbers suit this work better than failures that arrive as prose, whoever ships them.

Here's where I'd point a typed question first.

• Anything you currently trust because it sounds right. Accessible names, alt text and link text leave the least room for doubt, and cost the most when they're wrong.
• Route on the confidence, not only the answer. A low score that goes to a person is a working system.
• Write down what the options are. You can't ask one without first listing the acceptable answers, and that shows you which standards were never written down.

The conventions for all this are a week old. What happens to a low confidence score, and whether anybody routes it to a human, is being decided right now, mostly by people building real-time control loops for games and drones.

They haven't been asked who gets excluded when a check passes and nobody looks.

So take the check in your pipeline you trust most because it reads well. Work out what it would look like as a question with a fixed set of answers and a number on the end. It costs you an afternoon.