The $0.31 AI Job I Was About to Spend $50 On

I had a folder of 42,000 messages sitting on disk. Public YouTube live-chat, scraped from a stream I’ve been studying for a content project. The whole reason to pull them was to answer some very boring questions: which ones are questions vs. reactions vs. spam? Which name a specific tool? Which ones are the host actually engaging with? Standard classification work.

The plan was Claude. Cheap tier, batched, prompt-cached. Back-of-napkin math: somewhere between $15 and $50 depending on how badly I engineered the batching. Not scary money, but enough to make me want to test on 500 rows first, tune, then run.

Then a friend sent me the Jev launch blog and I lost an afternoon.

The model that doesn’t write

Jev is the first release from a San Francisco outfit called TypeSafe AI, launched September 15 with a $40M seed. The founder team is out of OpenAI. That part is not the interesting part.

The interesting part is that Jev doesn’t generate text. At all. You hand it some state — a string, or a JSON blob — and a set of typed questions, and it hands back typed answers with probabilities. There is no chat interface. There is no “please respond in JSON” ceremony. There is no possibility of a truncated response with a runaway ```json fence.

The three primitives it accepts are:

• Noul — a yes/no. You get back the probability of yes.
• Choice — one of up to 255 named options. You get the winner, the full probability distribution, and a confidence score.
• Score — a position on a 2-to-10-level ordered rubric. You get a probability-weighted mean.

That is the entire surface area. It’s a very narrow model doing one thing extremely fast — 70 to 500 ms per call, and priced at $0.042 per million input tokens with output tokens free.

The math that broke my afternoon

Here’s what my 42k-message job actually looks like on Jev. Average message is roughly 60 tokens. Each call needs the message plus the question definitions, call it 400 tokens total.

42,000 × 400 = 16,800,000 input tokens.

16.8M × $0.042 / 1M = $0.71.

Then I ran the numbers a second time because it felt wrong. Ran a small live test with the SDK. Real number came out under a dollar for the whole set. I’d been mentally budgeting fifty times that.

The Jev number came in under my Claude estimate not by 2x. Not by 10x. Something like 50–100x, depending on which Claude tier I was going to lazy my way into.

What the call actually looks like

Because “typed decisions” is the kind of phrase that sounds fake until you see the code, here it is, unedited from the SDK:

Three questions, one call, one parallel pass over the state. The confidence score is separate from the winning probability — it’s a summary of the shape of the distribution. A tight peak gives you 1.0; a wide spread gives you 0.0. You get to gate on both axes: “answer says X, but confidence is 0.3, so I don’t trust it — kick this one to Claude.”

That last part is where the architecture idea actually lives.

Cheap sieve, expensive reasoner

The thing I keep going back to is that I’ve been building AI pipelines wrong for two years. Every workflow I have on my machine looks basically the same: input → Claude → output. Sometimes there’s a Claude call in front of a Claude call. Sometimes the model is Haiku instead of Sonnet. But architecturally it’s the same one-shape thing — a general reasoner doing a job that is often not general reasoning.

The Jev-shaped rearrangement:

1. Jev pre-filters. Cheap, fast, honest-about-its-uncertainty. Runs on every item.
2. The confidence score becomes the routing key. High confidence + high probability → keep Jev’s answer. Ambiguous → hand it up to Claude with the original state and Jev’s distribution as context. Every-thing-is-null → send to a human.
3. Claude only runs on the hard ones. Which in most real workloads is 5–15% of the pile.

For my 42k messages, back-of-napkin: Jev handles maybe 90% at 0.3 cents. Claude handles the 4,200 ambiguous ones at maybe $2 total. Grand total under $3. Compared to $30 blasting Claude at all 42,000.

That number was already good. The routing structure is the durable win.

The skeptic’s corner (read before you ship anything)

Because this is the part every launch-week Jev post glosses over: “typed” is a format claim, not an accuracy claim. The top comment on the HN launch thread hammered exactly this — it can’t emit an invalid type, but it can absolutely emit a wrong valid answer. The 200x speedup number in the marketing is TypeSafe’s best case on their own evals. Real gains vary.

Independent evaluators have shown it doing things like putting 82.9% of the probability mass on face 1 of a fair die when the die is presented as text, which is exactly the kind of jaggedness you’d expect from a model that reads literally. It’s bad at counting. It’s bad at date math. It’s bad at multi-hop reasoning. Its own docs list nine failure modes on a page called “Jaggedness” that you should read before you write any real pipeline against it.

What I’m actually going to do with it

Three things, in order of how quickly they pay back:

1. Support inbox pre-triage. For any operator running a shared inbox, Jev can label every incoming email with is_urgent, is_billing, sentiment, has_named_competitor, before an LLM ever sees it. The LLM only opens the ones flagged interesting. This is a Fractional-CMO shape of offer that didn’t exist a week ago.

2. Lead-form ranking. Every lead form on every landing page dumps into a table. Score every row for probable_fit, probable_budget, probable_urgency, spam_signal. Sort. Route the top of the stack to a human, dump the bottom.

3. Content routing. For the daily blog and reel pipelines I already run: Jev scores each source note for has_technical_reveal, has_story_shape, mentions_person, mentions_dollars_in_client_context. That last one is a safety filter — a Noul that says “does this look like it would embarrass someone if published” — cheap enough to run on every draft, honest enough to gate publishes on.

The unifying idea in all three is that the LLM was always the wrong tool for the “is this worth an LLM call?” question. That question is a Noul. It costs 0.004 cents.

The takeaway

Every AI pipeline I’ve built has treated the model like a bouncer with a PhD — check every ID, think about every case, respond in prose. What Jev makes real is a bouncer with a clipboard. The clipboard bouncer costs almost nothing and is honest about the ones they’re unsure about. That’s the whole trick.

The uncomfortable part is that this rearrangement is not really about Jev specifically. If TypeSafe fumbles the ball, someone else ships the same shape in six months. The shape is what matters — cheap, typed, confidence-scored classifiers as the front of every AI pipeline, and general-purpose LLMs held back for the calls that actually earn their price.

The $50 I was about to spend was the tell. Any time an AI job feels like it should be a rounding error and isn’t, the pipeline is probably wrong before the numbers are.