A deepish dive on TypeSafe's Jev

The short version

I put a new kind of AI model through its paces: one that makes decisions for software instead of writing for people. My hobby project is software to help me keep track of the stocks I watch, so I was excited to play with Jev in that context. I rated 196 stocks with it and took one rating apart, about 1,400 calls for under 50 cents. Five things stood out:

1. Same facts, same answer. The probabilities held within a point or two across repeated runs.
2. Each signal answers to its own evidence. Remove the insider filings and only the insider call moves.
3. It notices when facts don't add up. Feed it an inconsistent scenario and the overall rating gets more cautious, not less.
4. It won't fake certainty. Not one STRONG rating across 196 stocks, even when every signal agreed.
5. The questions are part of the model. One sentence about when to use HOLD moved the HOLD count from 121 to 13.

I'm impressed. But buyer beware: I can't tell you much about how it's built.

A model that doesn't talk

Most of what we call AI today is built to talk to people. You ask, it writes, and somebody reads the answer and decides what to do. When we wire these models into software, we spend a lot of effort making them stop talking: forcing JSON, parsing prose, retrying when the format breaks.

Jev, from a San Francisco lab called TypeSafe, starts from the other end. It writes no text at all. You send it a pile of facts (the "state") and a set of typed questions, each with a fixed list of answers. It sends back a probability for every answer. TypeSafe's CEO, Diogo Almeida, calls it a "frontier-intelligence function call", and that is how it felt to use. His thesis is that people can't be the only consumers of intelligence. Much of the useful AI to come will sit inside ordinary software, making small judgments nobody sees.

I wanted to know whether that holds up on a problem I am somewhat familiar with. So I pointed it at my pet project, MarketInsights, the stock-analysis software I build in my spare time.

What I did

I asked Jev 1.13 to rate 196 US stocks from STRONG SELL to STRONG BUY. Then I took Apple's rating apart: the same question asked repeatedly, sections of the input removed, single facts changed, and the questions reworded. About 1,400 calls in all, every one answered by the same model snapshot.

The point was to understand how it decides. I didn't back-test whether its BUYs beat its SELLs. I wasn't focused on finding alpha; I just wanted to get a feel for how it worked in practice.

The input was facts only. Each stock got a JSON fact sheet: yearly financials from filings, price and valuation ratios, price trend, SEC Form 4 insider filings, the options-implied move, macro data, and management's own words from the latest earnings call. No analyst targets, no fair-value models, no AI-written commentary. Apple's sheet ran about 7,900 tokens, and 58% of that was the earnings call.

A few conventions mattered more than I expected. Units go in the field name (price_usd, dividend_yield_pct) so nothing has to be interpreted. Insider filing codes are spelled out, so a tax-withholding sale isn't mistaken for a vote of no confidence. Missing data is left out, and Jev is told that missing means unavailable, not bad.

The questions were typed. Seven per stock, each on an ordered scale from worst to best, each answer with a one-line definition:

All seven are answered in parallel and independently. The overall rating is not computed from the other six, and no question sees another's answer. The six signals are there so a person can see what Jev thinks about each factor.

What comes back is not a sentence. For Apple, the rating came back as BUY 55%, HOLD 39%, SELL 3%, STRONG BUY 3%. It cost $0.00033 and took about a quarter of a second.

Aha 1: Trust the probabilities, not the label

I sent Apple's identical fact sheet ten times. All seven answers came back with the same top choice every time, and the scores moved by one or two points at most. Coca-Cola came back HOLD ten out of ten, Nvidia BUY ten out of ten.

Then a second batch of ten came back HOLD once. The probabilities had barely moved. Apple simply sits near the line between BUY (52%) and HOLD (43%), so a small wobble can flip the label.

This is the first design lesson. The distribution is the stable output; the top label is only as stable as the gap between the top two answers. BUY at 52% and BUY at 90% are different judgments, and software built on a model like this should carry the probabilities through, not just the winner.

Aha 2: Each signal answers to its own evidence

Next I removed one section of Apple's fact sheet at a time and watched what moved. To compare, I turned each answer into a 0–100 score: the probability-weighted position on its scale. On the overall rating, one step (HOLD to BUY) is 25 points.

Two patterns showed up.

The signals are tightly wired. Take away the insider filings and the insider answer drops to Neutral. Nothing else in the fact sheet speaks to insider activity, and Jev doesn't invent it. Take away rates and credit data and it declines to call macro either way. Valuation stayed Overvalued even without the ratios, because the 38× P/E was still sitting in the market data.

The overall rating draws on everything and depends on nothing. No single section moved it more than 4.3 points, about a sixth of a step. Removing any single field moved it at most 1.1 points.

Size of input is not influence. The earnings call is 58% of the text and had the biggest effect on the rating, but only modestly. The price trend is 1% of the text and still moved the rating, and it moved momentum dramatically. Without management's commentary, Jev read the macro picture as more of a headwind and the business as slightly weaker. The CEO's words were softening its view.

This is what makes the output readable. The six signals act like a set of explanations you can check against the facts, without asking the model to write one.

Aha 3: It notices when the facts don't add up

Then I changed single facts and checked that the right signal moved the right way.

Every change moved the matching signal in the right direction, and the placebo did nothing. The brand name isn't doing the work. Its sense of value is strict, too: even at 15× earnings it called Apple fairly valued, not undervalued.

The moment that stuck with me came from a mistake. The first time I ran the P/E-15 scenario, I cut the share price and left everything else alone: the $345 52-week high, the last close, the moving averages.

The narrow valuation question took the low P/E at face value and said undervalued. The overall rating, which weighs everything, saw a stock trading 60% below where it was a moment ago and got more bearish. Narrow questions read narrowly; the broad question reconciles the facts.

The practical lesson is for whoever builds the scenarios. The model responds to the world you give it, so a what-if has to be internally consistent or you are testing your own typo.

Aha 4: It won't fake certainty

Four stocks were negative on all six signals: overvalued, deteriorating, in a downtrend, insiders selling, macro headwind, high risk. Jev still rated them only SELL, at 49–60%. Six-to-twelve-month stock returns are uncertain, and the probabilities say so instead of performing confidence.

That restraint may make this safer to automate against. A chat model asked for a rating will usually give you one with conviction. A decision model with a real distribution curve gives you something to work with.

The cross-section taught me one more thing. I asked which signals line up with the overall rating across all 196 stocks. Downside risk (rank correlation 0.75), macro (0.69) and fundamentals (0.58) tracked it closely; momentum and valuation barely did, and insiders not at all, because 127 of 196 stocks showed net insider selling. Macro is the interesting one. Rates and credit spreads are identical for every stock, yet Jev called them a headwind for 166, neutral for 27 and a tailwind for 3. It judges the same economy company by company.

For Apple, the price trend was the strongest lever. Across stocks, momentum hardly separates the BUYs from the SELLs. "What would change this rating?" and "What separates good from bad?" are different questions with different answers.

Aha 5: The questions are part of the model

I ran the same 196 fact sheets through four versions of the questions. Same data, same model, different wording.

One sentence of guidance decided whether 121 stocks or 13 sat at HOLD. Without it, the ratings split into BUY versus SELL.

Jev follows the logic of a definition closely. Write "all of these" and the answer becomes almost unreachable: under the lopsided version, Low risk went to 2 stocks. Write "any of these" and it fires often: High risk doubled to 61. Writing every scale symmetrically ("on balance…", risk relative to the average stock) gave balanced, usable answers.

None of the wording changes produced more STRONG ratings, so that restraint lives in the model, not the phrasing. Agreement between versions ranged from 34% to 95%.

In a decision model, the instruction text is a spec. It should be versioned, reviewed and regression-tested like code, because changing a sentence changes outcomes as much as, or more than, changing the data.

The economics change what's worth judging

Jev on OpenRouter costs $0.042 per million input tokens, and output is free. There are no output tokens to speak of: no reasoning trace, no prose, no JSON to generate. Apple's 7,900-token fact sheet with seven questions cost $0.00033 and came back in about a quarter of a second. The whole experiment, roughly 1,400 calls, cost under 50 cents.

With a chat model, output is where the money and the wait go. You pay for the model to think out loud, then to write an answer, then to format it, and you wait seconds for all three. Here the questions are answered in parallel in one call, and adding a question barely changes the latency.

Setup was easy. It's one endpoint on OpenRouter, three fields in the request (model, state, questions), and a typed answer that drops straight into code with nothing to parse.

At a fraction of a cent and a quarter of a second, the calculation flips. You can afford to re-rate every stock every time a fact changes, ask the same question five ways as a check, or run ablations like mine on a whim. Judgments that weren't worth a model call become worth one.

The part I can't see

I liked what Jev did. I can't tell you much about what it is, and anyone thinking about putting it into a real workflow will need to proceed cautiously.

The pedigree is serious. The founding CEO helped build the technique that made chat models usable, and his pitch is that the same technique made them overconfident. That's a credible reason to build something different. It is still a reason, not evidence.

Two marketing claims are worth reading carefully. "No hallucinations" means the answer always matches the schema; it can still pick the wrong answer. "Calibrated" is a claim I saw behave sensibly on 196 stocks over two days, which is not the same as calibrated to my use case.

If I were evaluating this for a business, I'd want answers to five questions first:

1. What was it trained on, and is there anything in that data I'd be uncomfortable defending?
2. Where does my state go? Calls pass through OpenRouter to TypeSafe. What is retained, and for how long?
3. Can I pin a version and get notice before it changes? Snapshots help; a deprecation policy matters more.
4. Is it calibrated on my problem? When it says 70%, is it right about 70% of the time on my data? Only my own tracking will tell me.
5. What's my exit? The typed questions are portable. The behavior behind them may not be.

My plan is to treat Jev the way you'd treat any new vendor in a decision path: run it in shadow, measure it, and keep a human on the decisions that matter until the evidence is in.

Where this goes

I expect the frontier labs to borrow this pattern. They already have most of the pieces: structured outputs, token probabilities, cheap small models. What they don't offer yet is the package. That means a decision endpoint that takes facts and typed questions, returns a distribution for each, and charges for what you send rather than what it writes.

The early signs are already here. Ten days after Jev's beta, OpenRouter launched a router that uses Jev to decide which chat model and how much reasoning each request gets. A decision model choosing which language model to call is a neat picture of where this is heading: chat models for the work people read, decision models for the judgments software makes.

For anyone building with this, my takeaways from this test:

• Keep the probabilities. Threshold on them, show them, and log them. The label alone throws away the most useful part.
• Design the fact sheet. Facts only, units in the names, missing means missing. The quality of the state is the quality of the answer.
• Version the questions. Treat definitions as code, with tests that re-run a fixed set of cases on every change.
• Keep scenarios consistent. The model reconciles the facts it's given, including the ones you forgot to update.
• Read the signals as the explanation. Independent, narrow questions tell you why the broad answer came out the way it did.

Caveats

This was one model version (jev-1.13-20260917) and two days of market data (1–2 October 2026). The removal and what-if tests used one stock, Apple; the cross-section used one call per stock. Because I ran hundreds of comparisons, a few small differences would show up by chance alone. So I only counted a change as real if it was clearly bigger than the normal run-to-run wobble and at least 2 points on the 0–100 scale. For me this shows how Jev decides, not whether it's right. Whether its BUYs beat its SELLs needs true back testing.

Sources

1. OpenRouter. "What is Jev?." https://openrouter.ai/blog/insights/what-is-jev/
2. Runtime Wire. "TypeSafe raises $40M for Jev." https://runtimewire.com/article/diogo-almeida-typesafe-jev-40m-seed-pong
3. Runtime Wire. "TypeSafe's Jev Router." https://runtimewire.com/article/typesafe-jev-router-openrouter-launch
4. StartupHub.ai. "TypeSafe Jev: the frontier model built to kill chat." https://startuphub.ai/ai-news/artificial-intelligence/2026/typesafe-jev-model-kills-chat
5. Dryhurst. "Jev on OpenRouter: Decisions API, pricing and latency." https://dryhurst.io/articles/jev-openrouter-decisions-api/
6. TipRanks. "OpenRouter highlights beta integration of TypeSafe's Jev." https://www.tipranks.com/news/private-companies/openrouter-highlights-beta-integration-of-typesafe-ais-jev-decision-model

← All musings · /product