When I built OfferPro, the hardest part was never getting the AI to read a real-estate offer. It was getting the answer back in a shape my code could trust.
An agent uploads a PDF. I need to know three things: is this offer strong for the seller, how confident should I be, and what should surface first. Simple questions. But the model would hand me a paragraph — "This is a competitive all-cash offer that comes in above asking..." — and then I'd write yet another layer to parse that prose back into a number. Half of what I called "AI" was really just babysitting text.
So when TypeSafe came out of stealth last week, the pitch stopped me cold: an AI model that doesn't return text at all. It returns typed decisions.
What Jev actually is
TypeSafe's model is called Jev, and it starts from one honest observation. Large language models are built to produce text for humans to read. But a lot of the time, the thing reading the answer isn't a human — it's your code. That's a mismatch, and every team papers over it with parsing, retries, and "please respond in valid JSON" prompts.
Jev skips the paragraph. You hand it state (your context) and a typed question, and it returns a structured answer: a value, a probability distribution, and a confidence score. There are three question types, and that's the whole surface area:
- Choice — pick from a set of options
- Score — rate something against a rubric
- Noul — judge how true a statement is, from 0 to 1
Small, composable, typed. You compose them in code instead of cramming everything into one clever prompt.
I rebuilt a slice of OfferPro in ten minutes
I didn't want to judge it on a toy, so in the playground I recreated the exact question OfferPro cares about: how strong is this offer for the seller?
The state was a real offer — 775K on a 750K list, all cash, no contingencies, a 21-day close. The question was a Score with a four-level rubric running from "weak" to "exceptional." Then I hit run.
Here's what came back:
- a score of 2.71 out of 3 — squarely in "exceptional" territory
- a confidence of 0.71
- a full probability distribution: 71% on "exceptional," 29% on "strong," nothing below
- 135 milliseconds and 18 output tokens
No paragraph. No parsing. My code reads the score straight off the response and moves on.
Why this is the right shape
Three things clicked while I was using it.
The output is a number, so I trust the pipe. Most of the fragility in an AI feature lives in the gap between "the model said something" and "my code understood it." Typed output deletes that gap. There's nothing to parse, so there's nothing to parse wrong.
It tells me how sure it is. This is the part I keep coming back to. A confidence score and a distribution mean I can set a threshold and design around it — above 0.8, auto-surface the offer; below it, flag it for the agent to eyeball. That's a clean product decision I could never make when the signal was buried in prose.
It's fast and cheap enough to stop rationing questions. Eighteen tokens and a tenth of a second means you don't hoard your one big prompt. You ask fifteen small typed questions and combine the answers in code — which is also just easier to reason about and test.
The honest part
It's early, and it's narrow on purpose. Jev won't write the note to the seller or summarize the deal for a client — that's still LLM work, and it should be. You also do more of the thinking yourself: instead of one fuzzy question, you break the judgment into atomic typed ones. For me that's a feature, not a chore, because that decomposition is exactly the part I want living in code where I can see it.
But the mental model is what I'll keep. A lot of what we ship as "AI features" isn't really chat. It's a judgment the product needs to make, hiding behind a text box. When you want a decision your code can act on, you shouldn't have to ask for a paragraph and hope.
I wanted a number. It's nice to finally get one.