Jev vs OpenAI structured outputsthe same object, a different guarantee
Both hand you a schema-valid object, and both can still be wrong about what is in it. Three things actually differ: structured outputs decodes token by token so you pay and wait for output tokens, you get one sampled answer instead of a probability over the options you declared, and nothing trained that probability to mean anything. If none of those bite, use structured outputs. You already have the key.
Last updated: September 2026
A free Jev-backed post scorer. No signup.
Start with what the objection gets right
The top comment on the Hacker News launch thread was some version of this is just structured outputs with extra steps. The sharpest phrasing was: "Sure, it cannot emit an invalid type, but it can still emit a completely wrong valid value. You can enforce structured output from an LLM too."
Both halves of that are true. Constrained decoding with strict: true already makes schema-invalid output impossible on OpenAI, and Jev's schema guarantee does not make its answers correct. TypeSafe's own launch post says the zero-hallucination figure "is not empirical" and that only "schema matching is guaranteed," and the CEO said the same thing in the thread. So the honest scoreboard on correctness is a tie, and any page telling you otherwise is repeating a press release.
What survives is narrower and more mechanical. Below is the whole of it, with arithmetic.
Side by side
| OpenAI structured outputs | Jev | |
|---|---|---|
| What the guarantee covers | The decoded JSON validates against your JSON Schema | The answer is one of the values you declared |
| How it runs | Autoregressive. One token at a time, with the grammar masking the sampler | One parallel pass. Every declared question is evaluated together, no decoding |
| Output tokens | Billed at the model's output rate | Free. TypeSafe does not meter them |
| What comes back | One sampled answer per field | Choice returns choice, probabilities and confidence. Score returns score, legend, probabilities and confidence. Noul returns a single float |
| Per-option probability | Only via logprobs, only when your options differ on the first token | Always, covering every option, summing to 1.0 |
| Calibration | Raw softmax over the vocabulary. Not trained to be calibrated | Trained for it, via RLCD. No calibration curves published yet |
| Free text in the same call | Yes. Add a summary or rationale string field to the schema | No. Jev cannot emit a string it was not given |
| Images, audio, video | Yes on the multimodal models | No. Text only, per the model docs |
| Schema-invalid output | Prevented by constrained decoding | Impossible by construction |
| Semantically wrong output | Possible | Possible. Same risk, same mitigation |
| Prompt caching and batch discounts | Yes on the major vendors | Not documented |
| Access | The key you already have | TypeSafe early access, waitlist. Or via Vercel AI Gateway, OpenRouter, Cloudflare |
Jev column from docs.typesafe.ai/primitives and /models, September 2026. Structured-outputs column from OpenAI's JSON Schema documentation. Both move. Check before you budget.
The same classification in both
One support ticket. Three judgments: which team owns it, how annoyed the writer is on a three-level rubric, and whether it is urgent. Here is Jev.
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
client = TypeSafeClient() # reads TYPESAFE_API_KEY
ticket = "I've been trying to connect my Stripe account for 3 days. Please help ASAP."
response = client.system_one(
state=ticket,
model="jev-1.13.0",
questions={
"department": Choice(
instructions="Which team should handle this",
criteria={
"billing": "Payment or subscription issues",
"technical": "Bugs or integration problems",
"sales": "Pricing or account questions",
},
),
"frustration": Score(
instructions="How frustrated the customer appears",
criteria=[
"Calm, just stating facts",
"Frustrated but civil",
"Very angry, strong language",
],
),
"is_urgent": Noul(
instructions="The message conveys urgency or time-sensitivity",
),
},
)
dept = response.answers["department"]
print(dept.choice) # "billing"
print(dept.probabilities) # {"billing": 0.84, "technical": 0.159, "sales": 0.001}
print(dept.confidence) # 0.596
print(response.answers["frustration"].score) # 1.035, a probability-weighted mean
print(response.answers["is_urgent"].noul) # 0.999
# A Noul answer has no .confidence field. The float IS the confidence signal.And here is the identical task with structured outputs.
import json
from openai import OpenAI
client = OpenAI() # reads OPENAI_API_KEY
ticket = "I've been trying to connect my Stripe account for 3 days. Please help ASAP."
SCHEMA = {
"name": "triage",
"strict": True,
"schema": {
"type": "object",
"properties": {
"department": {"type": "string", "enum": ["billing", "technical", "sales"]},
"frustration": {"type": "integer", "enum": [0, 1, 2]},
"is_urgent": {"type": "boolean"},
},
"required": ["department", "frustration", "is_urgent"],
"additionalProperties": False,
},
}
completion = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[
{"role": "system", "content": "Triage the support ticket."},
{"role": "user", "content": ticket},
],
response_format={"type": "json_schema", "json_schema": SCHEMA},
)
answer = json.loads(completion.choices[0].message.content)
print(answer["department"]) # "billing"
print(answer["frustration"]) # 1
print(answer["is_urgent"]) # True
# There is no second-place option and no probability here.
# One sample, three values, take it or re-run.One detail that tells you whether a Jev article was written by someone who ran it
A Noul answer returnsnoul, a float from 0 to 1, and nothing else. There is no confidence field on a Noul. Only Choice and Score carry one. Most third-party write-ups get this wrong, and at least one widely-cited explainer publishes a request body using options, min and max fields that do not exist in the API at all.About logprobs, because someone is about to say it
The fair rebuttal to "structured outputs gives you no probabilities" is that it does, sort of, through logprobs. That is a real answer and it deserves a real reply rather than a dismissal.
completion = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[...],
response_format={"type": "json_schema", "json_schema": SCHEMA},
logprobs=True,
top_logprobs=5,
)
# You now have, for every generated token, the 5 most likely alternatives.
# To turn that into "how likely was 'sales'" you have to:
# 1. find the token position where the department value starts
# 2. hope "billing", "technical" and "sales" differ at that first token
# 3. exponentiate the logprobs and renormalise over just those three
# 4. accept that the other 2 options may not appear in the top 5 at all
#
# It works for a 3-option single-token enum. It does not generalise.It works. For a three-option enum whose values differ on their first token, you can recover something distribution-shaped and it will often be useful. Three things break it. Two options sharing a leading token collapse into one measurement. A value that tokenizes into several pieces has no single position to read. And top_logprobs caps out, so an option that never enters the shortlist has no number at all.
The deeper problem is what the number means. A softmax over the vocabulary tells you how likely that token was under the decoder. It was not trained to answer "how often is this label right." TypeSafe's pitch is that RLCD trains for exactly that. Their pitch is also unaudited: no calibration curves, no Brier scores, no reliability diagrams have been published, and the docs themselves punt with "start with conservative thresholds, test with your own data." Treat the calibration claim as a hypothesis you verify on your own labels, not a spec.
For how to turn whatever you measure into a gate, setting a Jev confidence threshold walks through the thresholding method.
What 1,000 classifications cost
Same job, four price sheets. The structured-outputs question turns out to be a model-tier question.
Assumptions, so you can check the arithmetic:
- 1,000 items classified, one request each.
- 500 input tokens per request. Roughly 350 tokens of rubric plus 150 tokens of content.
- 40 output tokens per request for the LLMs. A small JSON object, no rationale, no reasoning tokens.
- Jev bills 500,000 input tokens and zero output tokens.
| Model | Input cost | Output cost | Total per 1,000 |
|---|---|---|---|
| Jev ($0.042 in, $0 out) | $0.021 | $0.000 | $0.021 |
| GPT-5.6 Terra ($2.00 in, $12.00 out) | $1.000 | $0.480 | $1.480 |
| Claude Haiku 4.5 ($1.00 in, $5.00 out) | $0.500 | $0.200 | $0.700 |
| GPT-5 Nano ($0.05 in, $0.40 out) | $0.025 | $0.016 | $0.041 |
Jev pricing from typesafe.ai. GPT-5.6 Terra rates as reported by The Register. Haiku 4.5 and GPT-5 Nano from the vendors' own published rates, September 2026. Verify every one before you plan a budget.
Read the last column twice. Structured outputs on a frontier model is about 70 times Jev. Structured outputs on a nano-class model is about twice Jev. So "Jev is 400x cheaper" is not a fact about structured outputs, it is a fact about which model you were using structured outputs on. TypeSafe says as much: it calls its own 193.6x and 444.6x headline numbers "on the higher end of real world gains," and against the comparable model on its own eval the real figures are closer to 25 times faster and 76 times cheaper.
The number that does not shrink is the output column. It is zero, and it stays zero when you add a fourth question, and a tenth. That matters more than the headline, because the natural way to use Jev is to ask many questions at once. Run your own workload through the cost calculator rather than trusting anyone's worked example, including this one.
One call, many questions
Because sampling is parallel rather than autoregressive, adding a question does not add a decode. It adds its own instructions to the input budget and nothing to the output bill. TypeSafe calls this speculative fan-out and its own cookbook reports a 13-question batch over one document running 12.2 times cheaper and 10.0 times faster than the equivalent calls, with no change in the answers.
OpenTweet leans on exactly that. The scorer behind /tools/will-it-go-viral asks seven questions in one request: one Score with a five-level reach rubric, three Scores for hook, clarity and specificity, and three Nouls for AI slop, engagement bait and toxicity. Seven questions is roughly 430 input tokens, about $0.000018 at the published $0.042 per million. Under structured outputs those same seven judgments are seven fields the decoder has to write out, one token at a time, and bill you for.
Which one belongs in your pipeline
Use structured outputs if
- You need generated text in the same call as the decision.
- Your input includes images, audio or PDFs.
- The schema is a nested object with arrays and optional branches, not a flat set of independent judgments.
- Volume is low enough that a 70x price gap on a frontier model is a rounding error.
- You cannot add a vendor, or you cannot wait on a waitlist.
- You want prompt caching and batch-API discounts on the same traffic.
Use Jev if
- The call is pure judgment: pick a label, rate a level, answer yes or no.
- You want a probability over the options so code can gate on it, not just the winner.
- You ask several questions about the same piece of text at once.
- The decision sits on a hot path where 8 seconds is not available and 200ms is.
- Volume is high enough that per-decision cost is a line item you talk about.
- You are happy to keep a separate LLM for the writing half.
These are not exclusive, and the interesting setups run both. Jev decides. An LLM writes. Then something has to actually ship the result.
Where the decision stops and the shipping starts
Neither Jev nor structured outputs posts anything. Once a draft clears whatever bar you set, publishing is one request.
curl -X POST https://opentweet.io/api/v1/posts \
-H "Authorization: Bearer ot_your_key" \
-H "Content-Type: application/json" \
-d '{
"text": "Shipping the new triage pipeline today.",
"publish_now": true,
"platforms": ["x", "bluesky", "linkedin"]
}'One POST, three networks. The same surface is exposed as a hosted MCP server, so an agent can take the same action. Get an API key or read the docs.
Frequently asked questions
Is Jev just structured outputs with extra steps?
No, but the objection is closer to right than the launch coverage admits. OpenAI structured outputs and Jev both guarantee a schema-valid object, and both can still be wrong about the content. The differences that survive scrutiny are three: structured outputs decode token by token so you pay output tokens and wait for them, you get one sampled answer rather than a probability over the options you declared, and the model was never trained to make that probability mean anything. Jev evaluates every declared question in one parallel pass, bills output at zero, and returns the full distribution. If none of those three matter to your workload, structured outputs is the right answer and you already have the key.
Can I get per-option probabilities out of OpenAI structured outputs?
Sometimes, with caveats. The logprobs parameter gives you the log probability of each generated token plus a handful of alternatives at that position. If your enum values happen to differ in their first token, you can read something that looks like a distribution over your options. That breaks the moment two options share a leading token, it does not survive multi-token values, and the numbers are raw softmax over the vocabulary rather than probabilities trained to be calibrated. Jev returns probabilities over the options you declared, whatever they tokenize to, and covers every option so the values sum to 1.0.
Does Jev cost less than structured outputs on GPT?
It depends entirely on which model you compare against, not on structured outputs as a feature. At 500 input tokens and 40 output tokens per classification, 1,000 classifications cost about $0.021 on Jev at $0.042 per million input tokens with free output. The same job on GPT-5.6 Terra at $2.00 input and $12.00 output is about $1.48, roughly 70 times more. On a nano-class model it is about $0.041, roughly twice. The price argument is an argument about model tier.
What can structured outputs do that Jev cannot?
Generate text. Jev cannot emit a string it was not given, so there is no summary field, no rewritten copy, no explanation of its own answer and no free-form extraction of a value that is not in your declared answer space. Structured outputs also work on images and audio, run on a vendor you already have a key for with no waitlist, benefit from prompt caching and batch discounts, and let you enforce arbitrary nested object shapes. Jev takes text only and is waitlist-gated in early access.
Does Jev eliminate hallucinations?
It eliminates schema hallucination, not factual error. Jev cannot return a value outside the answer space you declared, which is a guarantee by construction. It can still pick the wrong value from that space. TypeSafe says so in its own launch post, where the zero-hallucination figure is described as not empirical, and the CEO conceded the same point in the Hacker News thread. OpenAI structured outputs gives you the identical schema guarantee through constrained decoding. Neither one makes the answer true.
Can I use both in the same pipeline?
That is the shape most teams land on. Jev makes the cheap, high-volume judgment calls, an LLM writes whatever needs writing, and a publishing API ships the result. The free post scorer at /tools/will-it-go-viral is one worked example of that split: seven Jev questions on one draft, then a single POST to /api/v1/posts.
Do I need a Jev API key to try this?
To call the TypeSafe API directly, yes, and it is waitlist-gated at typesafe.ai. Jev is also reachable through the Vercel AI Gateway and OpenRouter, which is how most people got a first call in without waiting. Note that on the Vercel AI SDK the Noul question type is spelled boolean rather than noul, so do not copy a schema from one into the other.
Keep reading
The rest of the Jev cluster, plus the parts of OpenTweet that run on it.
Jev, explained for people who ship
What a System One model is, what it returns, and the parts of the launch claim that do not survive contact.
Jev vs Instructor and Guardrails
Retry until it parses, or cannot emit anything else. The difference shows up in your p99, not your bill.
Jev vs GPT-5 Nano
The closest rival on price. Worked arithmetic per 1,000 classifications, output tokens included.
Jev limits and rate limits
64k per request, 250k tokens per second, 1,200 requests per minute, text only.
Will it go viral, a live Jev scorer
Free, no signup. Seven Jev questions on your draft, with the confidence band the model actually returned.
The OpenTweet API
One POST publishes to X, Bluesky and LinkedIn. Where the decision ends and the shipping starts.
Jev decides. An LLM writes. OpenTweet ships it.
The scorer at /tools/will-it-go-viral is free and needs no signup. When you want the publishing half, plans start at $11.99 a month, with the REST API and the MCP server on every one.
- 7-day free trial
- No X developer account needed
- Cancel anytime