When AI stops explaining itself, you lose the argument
Google, OpenAI, Microsoft and Amazon are all shipping models that answer with a choice and a confidence number instead of a paragraph. The savings are real. So is what disappears, and creative work feels it first.
AI-assisted draft. Reviewed and edited by the Phosphene team before publication.
On this page

Google shipped a model this week that cannot write a sentence. You hand it a context and a closed question, and it hands back one option plus a number. Urgent or not urgent: 0.82. Billing or support: 0.16. That is the entire output, produced in something like 150 milliseconds.
Javier Lacort covered the launch for the Spanish outlet Xataka on 15 November and framed it as the direction the whole industry is moving. The naming and the timeline in his piece are specific: a startup called TypeSafe started selling these in September with a model called Jev, OpenAI followed a few weeks later, Microsoft and Amazon arrived in October, and Google's entry makes five. He also reports that TypeSafe's valuation reached 7.5 billion dollars within three weeks of launch, which is the sort of number that makes every other lab book a meeting.
I think the economics are as obvious as he says. The expensive part of a chat answer was never the thinking, it was the paragraph, and these models do not produce one. Amazon reportedly moved its internal ticket classification onto a decision model and cut the cost by more than a factor of forty. Output tokens are free when there is no output.
The receipt was the paragraph
Here is the part I keep turning over. A chat model was wasteful and verbose and frequently wrong, but it narrated. You could read four sentences of its reasoning, notice that it had misread a date, and stop it. The narration was not decoration. It was a partial audit trail, and it happened to be the most expensive thing in the response. Partial matters: a model's stated reasoning can leave out a factor that actually moved its answer, which is why you still check the conclusion against the file. But a partial record beats no record, and it costs a paragraph.
A number has no such surface. 0.16 is not a claim you can inspect, only one you can accept.
Lacort's examples are the ones that should worry anyone: whether your complaint goes to the front of the queue, whether your card gets frozen as suspicious at the worst possible moment, whether your question deserves the expensive model or the cheap one. None of those decisions will be visible. They happen inside systems you never open, made by models you cannot address, at a cost low enough that nobody will bother to build the explanation back in.
I have caught more model mistakes by reading three sentences of bad justification than by any evaluation harness I have run. When the justification disappears, so does my best error detector.
Your generation request was already a chain of these
If you make images or video with AI tools, none of this is new. It is just newly cheap.
A single generate button already runs a stack of small decisions before any pixels exist. Is this prompt acceptable under the provider's rules. Which model tier can handle it. What resolution and aspect ratio will the pipeline allow. Does this output duplicate something already in the library. Does this face resemble a reference closely enough to trigger a different path. Is this export permitted on the current plan.
Most of those are classifiers, and most of them are already the kind of model Lacort is describing. What you experience as a user is that the button worked, or that it failed with a message that tells you nothing.
The practical cost lands in one place: when a request is refused, you cannot debug the refusal, so you debug the image instead. You rewrite the prompt, change the wording, soften the adjective, drop the sentence you suspected. Three attempts later you have a worse prompt and no idea which change mattered.
Bisecting a rejection
There is a technique that works on opaque gates, and it is the same one you would use on a flaky test. Halve the input.
Take the prompt that failed. Cut it in half and submit both halves separately. If one half fails, keep that half and cut it again. Two to four rounds will usually isolate the phrase that flipped the decision. It is crude, it costs a few generations, and it converts a mystery into a boundary you can name and then work around.
The limit is worth stating. Bisection only works if some smaller fragment reproduces the rejection. Plenty of gates score the whole prompt at once, so both halves can pass separately while the combination fails, and the halving stops dead. When that happens, stop cutting and start pairing: test the suspect clause next to each of the others, one at a time, until you find the pair that trips it. Pairing only sees pairwise interactions — a gate can reject A, B and C together while accepting every pair. If all the pairs pass and the full prompt still fails, escalate to triples, and accept that some triggers only appear at full size. Combined triggers are the expensive case, and they are also the ones where a reason field would have saved you an afternoon.
What you get at the end is not a rule the model told you. It is an empirical edge: this construction trips the gate, that one does not. That is enough to build a working prompt, and it is honest about how little you actually know.
What a score is allowed to decide
The useful distinction is not "score good" or "score bad". It is what category of decision the score is permitted to settle.
A confidence number is a fine way to sort a queue. Route the 0.94s automatically, send the 0.55s to a person, and the model has bought you real speed without pretending it knows why. That is what decision models were built for. The threshold is the part you have to earn: measure how often the model is wrong at each candidate cutoff, on labelled examples from your own task, before you let a high score skip a human. Confidence is not correctness, and a threshold picked by feel will let the expensive errors through first, because those are exactly the ones the model was sure about.
A confidence number is a bad way to refuse someone. Refusal needs a reason the person on the other side can act on, because the whole point of a refusal is that they are supposed to change something. If the only feedback is that a gate closed, the rational response is to guess, and guessing is how people end up with prompts that dodge filters instead of prompts that describe what they want.
The same test applies to review inside a creative pipeline. A cheap scorer that flags the forty worst frames out of four hundred is a gift, because a human still looks at them and the human supplies the reason. A scorer that silently deletes the frame is a different product, and it is a worse one. Once the score is the objective rather than a filter, the work starts optimising for the score, which is the whole story of reward hacking. This is the failure we already documented with detector scores treated as verdicts: the number was accurate and the decision built on top of it was not.
Two things worth asking for
If you are building with these models, or buying from someone who does, two requirements cost almost nothing and change the failure mode completely.
Keep a reason string next to the score, even a crude one: which rule fired, which threshold was crossed. You do not need a paragraph of chain of thought. You need one field that distinguishes "this looked like a payment fraud pattern" from "this tripped a keyword list", because those two failures have different fixes and only one of them is your fault.
Log the input that crossed the threshold. Even without any explanation from the model, a record of the exact prompt that scored 0.83 next to the one that scored 0.79 turns an unfalsifiable gate into a map you can redraw. Prompts carry personal data more often than builders expect, and sometimes credentials pasted by accident, so redact before you store, restrict who can read the log, and put an expiry date on it. This is the same discipline as keeping a look sheet for a batch: the decision that is recorded can be argued with later, and the one that lives only in a session's memory cannot.
I am not arguing against the cheap model
Cheap, fast and reliable is a good trade, and most of the decisions in that stack genuinely do not deserve a paragraph. Routing a support ticket through a frontier model is waste, and the companies cutting that waste are right.
What I object to is the assumption that the explanation was overhead. It was the part that let a person catch the model being wrong, and it was already being paid for by the same token budget that made these models look expensive. Remove it and you have not just saved money. You have moved the cost of every mistake onto the person downstream, who now has to guess at a boundary instead of reading a sentence.
Cheap decisions are fine. Unappealable ones are not. The number is welcome to sort my queue. It should not be the last word on my work, and right now nobody shipping these models seems to have decided which of those two jobs it is doing.