The model that never writes.

The API has two endpoints and the request has three fields: the state, the model, and a map of questions.4 A question is one of three kinds. A Noul is a yes/no proposition and comes back as a probability. A Choice is a set of named options, up to 255, and comes back as a full distribution plus the winner. A Score is an ordered set of described levels, up to ten, and comes back as a probability-weighted position on that scale. Nothing else exists. There is no free text out, no way to get one, and the founder says that is deliberate: strings are "not allowed at all", because that is what lets every answer be computed in parallel.2

Two properties of that call matter more than they look. Every question in a request is evaluated in parallel against the same state, so asking thirteen questions costs about the latency of one; TypeSafe measured the batch as twelve times cheaper and ten times faster than thirteen separate calls.4 And the question key is never shown to the model. urgent is for your code; the model reads only the instructions and the criteria.

How it works is undisclosed. No paper, no base model, no parameter count. What can be reconstructed from outside is convincing enough: a large pretrained transformer reads the state and the schema once, and for each question the final hidden state goes through the language-model head, only the logits for the allowed answers are kept, and a softmax turns them into probabilities. One forward pass per question over a shared cache. That explains all four headline properties at once. No generation, so it is fast. The answer is a softmax over permitted tokens, so the JSON is always valid. A softmax is a distribution, so you get probabilities free. Output tokens never exist, so they cost nothing.5 Archer Hume put about ten thousand calls through the API to confirm the shape: fifteen hundred questions on one short state still came back in a few hundred milliseconds, options are scored jointly rather than independently, and reversing the option order can move a probability from 0.84 to 0.95 on identical evidence.5

The training method has a name, Reinforcement Learning for Calibrated Decisions, and one sentence of description: the probabilities are optimised against outcomes so that higher confidence means higher accuracy. The data is entirely synthetic, which Almeida calls a better bet than RLHF itself.6 Sebastian Raschka's read is the one I trust: encoder classifiers have existed for years, but each was trained for its labels. What is new is a general one that reads arbitrary labels at request time, at roughly Flash-class comprehension, in a tenth of a second, and the moat is almost certainly the data rather than the algorithm.7

TypeSafe's own evaluation is unusually candid. Four real workflows, 711 cases, with GPT-6 Astra and Claude Fable 5.1 averaged as the reference answer. Jev scores 67.8% mean accuracy. GPT-5.6 Sol scores 74.1% and Claude Opus 5 scores 73.1%. So it is six points below the best models on judgement, level with Terra and Sonnet, at $0.0004 and 0.4 seconds per case where Opus costs $0.18 and 38 seconds.8 The 193x and 444x on the homepage are Jev against Sonnet on time and against Opus on cost, the worst point on each axis. Their own blog says these are "on the higher end of real world gains".

The independent measurements, all from the last six days, tell a consistent story, and the fair comparator is a Flash-class model rather than a frontier one.

Read the last two rows as carefully as the first six. When you already own labelled data for a fixed task, a trained specialist still beats it. Jev wins when the labels change at runtime, or when there is no training set and never will be. That is most of the judgement in a small company.

The claim that worried me most was calibration, because the whole product is the threshold: act above it, ask a human below it. It holds, in every independent test that checked the top bucket. Bryo's 737 predictions at 99% confidence or above were all correct; below 70% nearly half were wrong. Lindfors found the 0.9 to 1.0 bin right 98% of the time and the 0.3 to 0.7 bin right 34%. Hume measured an expected calibration error of 0.031 on twelve hundred MMLU items.9105 Two studies on their own distributions found worse overall error, 0.11 and 0.14, so you measure it on your data before you trust it. But the shape is real: when it says 0.95 it is right about 95 times in a hundred, and that is the property nobody has been able to buy from a chat model at any price.

And the failures, which TypeSafe lists on a page called "model jaggedness" with a fix beside each one.17 It reads literally. It cannot add, count, or compare dates. It gets worse as you pad the state with things the question does not need. It does not treat the state as hostile, so a message saying "ignore your instructions" can move the answer. A proposition and its negation do not sum to one; their own numbers give 1.19. It is not deterministic, only consistent, and it cannot reason: in a solver-verified poker test it shoved with the nuts sixteen times out of sixteen in a spot where the answer is to check, and a form-filling agent built on it alone completed zero of thirteen steps.18 "Zero hallucination" means the JSON is always valid and nothing else. As Armin Ronacher put it, "it delegates the hallucination problem a little bit to the user."6

Mike Maples has a four-question test for whether something is a real turning point or just an improvement curve, and the fourth question is the one everybody skips.19 Here it is, applied.

What is the specific new thing? A general-purpose judge that reads labels defined at request time, returns a calibrated probability, and costs four hundredths of a cent and a tenth of a second per decision. Classifiers existed. Cheap classifiers existed. A general one with honest confidence, at a price where you never ask "should we run the model on this", did not exist on 14 September.

Who does it newly empower, and how? The person or the two-person team who has judgement-shaped work at volume and no team to do it: moderation, triage, review, scoring, ranking, verification. Until last week that work was priced in human hours or in chat-model seconds, and both prices meant you did it on a sample. Now you do it on everything, continuously, and the marginal decision is free. The Good Start Labs number is the cleanest version: grading a million research answers went from $33,000 to $160.12 That is a queue that was staffed becoming a queue that is computed.

Under what conditions is it realised? The question has to be closed. The input has to be text. Somebody has to write fifty labelled examples to set the threshold, and that somebody has to understand the domain well enough to write criteria a literal reader cannot misread. The struggle has to exist already, visibly, in public: people complaining about the queue, paying for the queue, quitting because of the queue.

Under what conditions might it not be? Four that I can name. OpenAI or Anthropic ship a decisions endpoint on their small models, which the Hacker News consensus expects within months, and every Jev integration becomes a config change; that commoditises the model and leaves the products standing. The $42 price turns out to be subsidised; TypeSafe says it can serve profitably and admits it cannot prove it.1 Calibration fails on your distribution, which you find out for two dollars. And the servers are US-only with no EU option, which kills anything touching regulated European data until that changes.

It passes. The commoditisation risk is the real one, and it cuts the right way: if the model becomes a commodity, the value is in knowing which decisions to ask and how to write them, and that is exactly the part that takes domain knowledge. Which brings me to the part of this I am actually qualified to write.

Saras Sarasvathy studied thirty expert founders working the same product idea and watched them build companies in eighteen different industries. The idea did not determine the business. The founder's means did: who they were, what they knew, whom they knew.20 So before the list, the means, from the record rather than from my opinion of myself.

Nine years of commits across 109 projects. Scraping and data pipelines since the first year and never stopped: twenty projects. AI on twenty-five projects, all since 2023, and most of what I do now is agent harnesses, the machinery that makes coding agents produce work I would sign. Blockchain on fifteen, trading on thirteen, reverse engineering on six. Two live shows' worth of broadcast tooling built this year. Communities I can reach: a handful of crypto Telegram groups, some of them large, a Solana builder chapter I do work for, and the audience of a weekly show about what is real in crypto that I am building the studio for. And a temperament I have written down enough times to trust: I am better at optimising inside boundaries that already exist than at inventing new ones, and I want to be new by a small margin.

That narrows the search to three lanes, and I generated inside them rather than in the abstract. Every idea below names the input that produced it: an observed complaint, a distortive process people endure, a purchase that is already happening. If an idea could have occurred to anyone who read the launch post, I cut it. Paul Graham's rule: "if all you know about a startup idea is that it sounds plausible, you have to assume it's bad."21

Everything above is a queue with Jev at the front of it, which is the frame Greg Isenberg gave and the one most of the first week's builds fit.40 Five things do not fit it, and they are the ones I keep thinking about.

Ask the whole decision tree at once. Because two hundred questions cost the latency of one, you can evaluate every branch of a workflow speculatively and let code walk the tree afterwards. An agent that makes six sequential model calls to plan a step can ask all six on the current state in one call and only wake the expensive model at the leaf that needs prose. This is why the browser agents went from ten seconds a step to under two hundred milliseconds.41 Any workflow with a chain of small decisions is a candidate, and most business software is that.

Judge the program, not the text. Almost every demo feeds Jev a message. Feed it your application's internal state instead: the task queue, the last five agent turns, the board. "Which task is stalled." "Which agent is going in circles." It reads JSON as well as prose, and that turns monitoring from a dashboard someone has to look at into a decision the system makes.

Filter instead of summarise. Any "summarise this history" step can become "score and drop from this history", which is faster, cheaper and never paraphrases. The Claude Code plugin that did this got the implementation wrong, but Almeida endorsed the direction: freeing agents from designing around the cache.31 Wherever you own the harness, it is the right primitive.

Ambient interfaces. Keystroke latency means a UI can ask a question per keystroke. A launcher where "the pdf I just downloaded" is already the top hit, a paste that knows what it is and where it goes, a find-in-page that finds meaning. Caleb's line on the video explainer stuck with me: it "almost feels like we're back to logic gates and registers, and now we have to build many abstractions on top."42 The abstractions are the products.

Score everything, always. At this price the question is never whether to run the model but what you would do with the answer. Every tweet, every message, every commit, every log line, every note, scored on the questions that matter this month, continuously. The scoring is nearly free. The discipline is writing the questions and then not building a dashboard on top of them.

Three, in order, and the reasoning is the same for each: I already have the data pipeline, I already have the people who would use a bad first version, and the test costs a weekend.

The community operating system first, because the desperation is highest, the reference implementation exists, and I am in the groups. A moderation product is boring and has competitors, which Y Combinator would tell you are two of the three properties that make an idea look bad and therefore good.43 The thesis everyone in that market has missed is the pardon loop: a bot that learns each group's culture from its admin's corrections, without a training run, is something the incumbents cannot do because they were built before a model could read runtime-defined labels.

The foreman second, because it is the thing I would build for myself regardless, and the window before the labs do it well is real but short. It is also the one where being wrong costs the most, which is why the first hundred sessions are my own.

Narrative radar third, because traders are hostile to it, the pipeline is already running, and publishing the hit rate in public for a month is a test that cannot be argued with. If the record is bad, I will have learned it for the cost of the scraping I already pay for.

The rest stay on the shelf as tools until one of them makes someone angry.

Starting from the technology. Every idea here began as "Jev exists, what could I do with it", which is the failure mode called solution-first, and I know it. The defence was to insist on a named input for each: a complaint I have heard, a process I have watched people endure, a purchase that is already being made. Four of the twenty I flagged as weak on exactly that test, and I left them in so you can see the difference.

Treating a Flash-class judge as an oracle. It is six points below the best models. Anything where one wrong answer is expensive and nobody will look needs the confidence gate, and the gate needs fifty labelled examples from your own data before it means anything. Two dollars and an afternoon. Skip it and you have built a machine for being confidently wrong at scale.

Forgetting the clones. Five open imitations shipped in 72 hours, and the labs will follow. Nothing here depends on TypeSafe surviving. Everything depends on knowing which questions to ask, in what words, with what threshold, for a group of people you can reach. That is the part that does not commoditise.

Building the system instead of the thing. My own worst habit, and this technology feeds it: it is very cheap to score everything and very tempting to build the dashboard that shows the scores. Every idea above has a test that is cheaper than building, and the rule I am holding myself to is that the test runs before the repo is created.