On October 9 they raised an $870 million Series A at a $7.5 billion valuation, led by a16z with Sequoia and DCVC. That was 24 days after launch. Twenty-four days.

On October 14 they shipped Jev 1.14: pictures, a new Box answer type that finds things in an image, and long context up to 262,000 tokens.

I spent the day after it shipped throwing it at my own notes, a phone photo of a circuit board, and 88 illustrations from a 1919 edition of Aesop. I also ran it against the other decision models, because in one month Jev went from the first of its kind to one of eight models on the same OpenRouter endpoint.

Jev got company, fast

Jev named the category. It didn’t stay alone in it for long.

• September 30: Inception’s Mercury Decide shows up on OpenRouter at $0.02 per million input tokens.
• October 1: Perplexity open-sources a 27-billion-parameter decider under Apache 2.0, and ships v1.1 five days later.
• Early October: Cloudflare ships Clef and Clef Flash, Amazon ships Strands Decider, Databricks ships ai_decide.
• October 6: OpenAI opens its Decisions API on GPT-6 Luna to every developer.
• October 9: Microsoft ships Microsoft-Decision-1, the same day as TypeSafe’s Series A.

On September 23 I logged a call that one of OpenAI, Anthropic, or Google would ship a typed-decision endpoint before March 31, 2027. OpenAI did it 13 days later. I’ll take the win, even if I set the bar a little low.

So for 1.14 I wanted more than a list of what’s new. I wanted to know how Jev stacks up now, and I had a way to find out.

Eight decision models, one notebook

Sieve is my open-source tool for asking questions of a folder of notes with Jev. It has an eval command that measures accuracy against labels I already have. My research notebook has 240 insights, predictions, and trend signals that I filed into six topics by hand, so that’s the test: strip the topic tags, ask “which topic is this mainly about?”, and count.

OpenRouter now serves eight decision models from five companies behind one endpoint with one request shape (two of the eight are Jev 1.13 and 1.14). I added a backend profile for each and ran the same eval on all of them.

The first table looked like a clean Jev win on speed and a muddle on accuracy. Then I noticed I had stacked the deck.

Sieve packs 16 notes into one request by default, because it’s cheaper and faster. I had run Jev that way, and also one note per request. Jev scored 78.8% packed and 72.9% one at a time. Every other model I had only run one at a time. Not a fair fight.

So I reran Perplexity, OpenAI’s Luna, Inception’s Mercury, and Clef Omni at 16 per request. Cloudflare’s Clef and Clef Flash stayed at one, because OpenRouter’s docs say they only read about the first 2,000 tokens of text, and 16 notes would get cut off.

With 240 notes, any single accuracy is good to about five points either way. So I compared models note by note instead, with a paired test on the same 240.

Perplexity’s decider is more accurate on my notes. It got 22 notes right that Jev 1.13 missed, and Jev got 7 right that Perplexity missed (p = 0.008). It’s also better calibrated for acting on. If I want 90% accuracy, Perplexity lets me act on 85% of my notes at its threshold, and Jev about half.

Jev is the fastest by a wide margin. 0.6 seconds for all 240 (1.0 on 1.14), against 2 to 15 seconds for the rest. For anything inside a loop, that matters more than a few points.

Mercury leaned ahead of Jev but not by enough to call it (16 to 7, p = 0.09). Clef tied Jev exactly (13 to 13), even though Cloudflare says Clef leads seven of ten decision benchmarks.

Two oddities. Perplexity’s cost went up about ten times when packed ($0.0038 one at a time, $0.0366 packed), as if each question is billed against the whole request. And Luna billed nothing one at a time and a tenth of a cent packed, which I read as a launch promotion.

One labeled set is one labeled set, and this was one of ten comparisons, so even p = 0.008 is borderline once you correct for that. I’d want a second set before calling Perplexity the better model in general. On my notes, today, it is.

What 1.14 changed, and what it didn’t

On English routing, 1.14 is 1.13. They gave the same answer on 228 of 240 notes (p = 0.75). TypeSafe said the biggest gain would be multilingual, and my notes are all English, so I didn’t test the part they said improved most.

Packing helped both versions. 16 per request beat one per request (p = 0.013 on 1.13, 0.004 on 1.14).

That one surprised me, because OpenRouter quietly runs any request over about 32,000 bytes in TypeSafe’s long-context mode, which the docs call slower and less accurate. At 16 notes per request, 95% of Sieve’s requests on my notebook cross that line. Accuracy held anyway. 16 per request even edged out 8, which stays under the line, though not by enough to call it (p = 0.06 on 1.13, 0.09 on 1.14). My guess is that seeing the neighboring notes gives Jev some context for “mainly about.”

Long context is the real upgrade

This is where 1.14 earns the version number.

I took up to 522 of my own voice briefs and news notes, about 210,000 tokens, and planted one sentence that contradicts a note. The first plant was off topic (a hardware note about a microphone interrupt pin, sitting among AI news). I put it at 10%, 50%, and 90% of the pile, and kept a copy with no planted sentence as a control. Then I asked one question: does anything in here contradict this note?

Both versions found the sentence at every size and depth. The difference showed up at the far end. At 210,000 tokens, 1.13 dropped to 0.63 and 0.65 when the sentence sat in the middle or near the end. 1.14 held at 0.81 and 0.87.

One trade-off showed up when I planted a sentence on a topic the notes also cover (a claim about Jev, among news about Jev). 1.14’s control scores crept up with size, from 0.13 to 0.27, while 1.13’s stayed near 0.10. Both still separated cleanly, but a threshold tuned on a short notebook needs a second look on a long one.

A 210,000-token request took 1 to 4 seconds and cost under a penny.

Pictures work, with three surprises

Jev 1.14 reads images. TypeSafe labels this “Dreamer-ready,” meaning good for prototypes, not production. That label turned out to be fair.

Surprise one: the format. TypeSafe’s docs send images in an assets map. Through OpenRouter, that gets silently dropped. My first test sent a 1.7 MB photo, billed 395 tokens, and got answers that were clearly guesses. OpenRouter wants the image inside the state as an image_url part, the same shape chat models use. Sent that way, the same photo billed 2,408 tokens, and Jev called it a round circuit board at 0.96 and picked “a ring of LEDs” around the edge at 0.99.

Surprise two: the size limit is wrong. The docs say each side must be 256 to 1,568 pixels. Every image I sent with a side between 256 and 279 came back “Invalid image dimensions.” 280 worked. And one bad image fails the whole request, so a single small picture took down a batch of 16.

Surprise three: pictures bleed into each other. I asked all 313 fables “does the picture show a bird?” “The Boy and the Filberts” has no picture and no bird, and it scored 0.94. It had shared a request with “The Frogs Asking for a King,” whose picture shows a stork eating frogs. With eight pictures in one request, Jev mixed up which picture went with which fable. At one picture per request, none of the 172 fables with no picture and no bird scored above 0.3. That costs about 15% more, and it’s now how Sieve packs pictures.

Box finds the fox, then finds it again

Box is the new answer type: “where is the coffee mug in this photo?” comes back as four edges.

On a phone photo of a circuit board, it nailed three targets on the first try: the logo, the main chip, and the red square in the middle.

On illustrations it was looser. I asked for “a fox” in all 88 illustrated fables. The yes/no part was excellent: 15 pictures at 0.95 or higher, then a gap to 0.27. The boxes contained the fox 13 times out of 14, but often took half the picture along for the ride.

TypeSafe’s Box page suggests a fix, so I tried it. Crop to the first box with a margin, scale the crop up, and ask again on the crop. Then 15 of 15 framed the fox, about 13 of them tightly, including a small fox at the bottom of a well that the first look had turned into a sliver.

The confidence numbers told the same story. On the first look they ran 0.05 to 0.26, even on good boxes. On the second look, 0.35 to 0.80, highest on the tightest ones. The second look cost about three thousandths of a cent per picture.

Two editions of Aesop, matched by story

The fables in Sieve’s demo are George Fyler Townsend’s 1867 translation. The pictures come from The Aesop for Children, illustrated by Milo Winter in 1919. Different edition, different titles, different retellings.

So I had Jev match them by story instead of title. On the 53 fables whose titles match exactly in both books, it picked the right one 53 times. It also matched “Belling the Cat” to “The Mice in Council,” and “The Fox and the Stork” to “The Fox and the Crane,” where the titles don’t agree.

Then I flipped it around and asked which pictures disagree with their own text. The top answers were all real. “The Hen and the Golden Eggs” scored 0.98, because Milo Winter drew a goose. “The Two Travelers and the Axe” scored 0.93, because his travelers find a purse.

What’s new in Sieve

All of this went into Sieve as I tested it.

• Pictures as notes. A folder of PNGs and JPEGs becomes a set of notes, and a Markdown note brings along the picture it links, alt text included.
• Find. sieve find "the fox" asks every picture whether it is there and where, and --refine takes the second look on a crop.
• Against. sieve against "<note>" asks whether anything else in the folder contradicts one note, in one request per 250 notes. My whole 1,407-note notebook took 6 requests, 1.9 seconds, and under three cents.
• Any decision model. Backend profiles for Perplexity, Cloudflare, OpenAI, and Inception, and eval --items so you can compare two models note by note.
• Safe image handling. Size checks before anything is sent, automatic resizing with ffmpeg, and one picture per request.
• The illustrated fables. One command fetches Milo Winter’s public-domain illustrations from Project Gutenberg and matches them to the fables.
• Pictures in the web UI, with Find in picture drawing the box on the illustration.

What I’d watch next

Jev started a category, and a month later it’s not the most accurate model in it (at least on my notes). It’s still the fastest, still cheap, and 1.14’s long context is a real step.

What I’d watch is which wrapper wins. When the decision itself is available from five companies on one endpoint, at fractions of a cent per run, the value moves to the part that tells you which one is right for your notes, and that part only you can run.

It did not write a single word back.

That’s Jev, and I think it’s one of the more interesting models to show up this year.

Yes, I made the meme. Jev couldn’t say that line if it tried. You’d have to ask it a yes/no question.

What Jev is

Jev comes from TypeSafe, a San Francisco lab that came out of stealth on September 15. OpenRouter added it three days later as typesafe/jev-1.13, so if you have an OpenRouter key, you already have Jev.

Every frontier lab has spent the last two years teaching models to think longer. TypeSafe went the other way. Jev reads whatever you hand it and answers one of three kinds of question, using only the options you give it.

• Noul: yes or no, as a probability.
• Choice: pick one of up to 255 options you describe.
• Score: place it on a scale you define, “Can wait” to “Blocking revenue right now.”

Every answer comes back with probabilities. No prose to parse, no JSON that’s almost JSON, no invented option. It’s an if-statement that understands English.

It’s also cheap: $0.042 per million input tokens, and output is free. My first call, three questions about one support ticket, came back in 0.6 seconds and cost $0.000017.

Where it fits

Most decisions inside software aren’t essays. They’re “which team gets this ticket,” “is this safe to run,” “is this spam,” “which of these 40 things matters.” We’ve been paying a chatbot to write a paragraph so we could regex one word out of it.

• Routing and triage. Tickets, emails, alerts, pull requests. Pick the queue, score the urgency.
• Gating agents. Before an agent issues a refund or runs a command, ask three yes/no questions. At 0.9 or higher, go. At 0.1 or lower, stop. In between, a human looks. OpenRouter published exactly this recipe.
• Checking an LLM’s homework. Did the answer stick to the source, or make something up? Ship the supported ones, escalate the rest.
• Sorting big piles. Thousands of documents, one question each, ranked by probability.
• Picking instead of writing. Pull the candidate dates or amounts out with a regex, then let Jev choose the right one.

The probabilities are the part I didn’t expect to love. When the model is unsure, it says so, and you fix things by moving a threshold, not rewriting a prompt.

What I built with it

My research repo has 1,140 items in it: voice briefs, news digests, insights, bets, trend signals, blog drafts. I built a thing called Sieve that asks Jev the same question about every one of them and ranks the answers. “Talk-ready.” “Evidence against my community thesis.” “Feeds chapter two of the book.” “A hands-on build that could be demoed live at a developer meetup.” (My CABLE 82 talk came back first, at 95%. Correct.)

Then I checked it against my own filing. I’d already sorted every insight and trend signal into swimlanes by hand, so I stripped the labels and asked Jev to do it. Overall it agreed with me about 8 times in 10. When it said it was confident, 9 times in 10. When it was unsure, it was close to a coin flip, and it told me so.

Sieve is open source

I split Sieve into the engine and my stuff, and put the engine on GitHub: github.com/nothans/sieve. MIT licensed, just Node, no dependencies. Point it at any folder of Markdown, describe what counts as an item and which questions you care about in one config file, and it sifts the whole pile from the command line or a little web UI. My research notes and my config stay on my machine.

It ships with two demos: a made-up research notebook, and all 313 of Aesop’s fables. Ask the fables for “a trick that backfires on the trickster” and it reads every one of them in 1.4 seconds for about a third of a cent.

The Moral preset files every fable under its moral. The Dog and the Shadow came back 100% greed, which seems fair to the dog.

The repo also carries the Jev command-line tool on its own, so any script or agent can grab a typed answer when it needs one.

What tripped me up

Jev reads literally. Really literally. “Projects I could demo live on stage” ranked a Google product launch first, because Jev has no idea who “I” is. “Is this evidence against my thesis” came back as a shrug on everything. Asking for the concrete thing instead (“does this report a community that did fine without human trust?”) fixed it. TypeSafe documents all of this: no math, no counting, no date comparisons, and adversarial text can push it around. It also can’t tell you why, so you get a number and no reason.

The idea is already loose, too. Six open-source clones showed up within about 48 hours, at least one of them running on a single gaming GPU. What got copied is the shape: state in, typed questions in, probabilities out. I think that shape sticks around, whoever ends up serving it.

Creative uses I want to try

• Board game bots. A playtest bot that picks its move from the legal moves, with a persona written in the question.
• A notification bouncer. One yes/no before anything pings my phone: “Is this urgent enough to interrupt someone at dinner?” (Not “would I want this.” Jev doesn’t know who I am.)
• CABLE 82 tonight. Score every headline on “cozy Friday night viewing” and let the 1982 cable channel build its own lineup.
• Moderation with the thresholds in public. Every post gets the same small set of typed judgments, and members can see, and vote on, the numbers that decide what happens.
• A code review tripwire. “Does this diff touch authentication or payments?” before an agent is allowed to merge.
• Alt text that checks itself. Does this description actually say what the chart shows?
• Spreadsheet columns that think. Add a column called “urgency,” type what it means, fill 300 rows in seconds.
• Training its own replacement. Label a big pile of examples with Jev, then train a tiny local model on the labels.

It’s the first AI model I’ve met that’s better at listening than talking.

I know a few people like that. Not many.