Jev vs GPT-5 Nanothe arithmetic, with the work shown
Nano is the closest thing Jev has to a price rival, and the gap is narrower than the launch coverage implies. On a bare label it is about 2x. It only widens to about 10x when you let Nano spend reasoning tokens, because reasoning tokens bill as output and Jev does not bill output at all. Every number below is multiplied out so you can check it.
Last updated: September 2026
Free, no signup. About 430 input tokens a scored draft.
The price sheets
| Jev (jev-1.13.0) | GPT-5 Nano | |
|---|---|---|
| Input, per 1M tokens | $0.042 | $0.05 |
| Output, per 1M tokens | $0.00, unmetered | $0.40 |
| Output rate as a multiple of input | 0x | 8x |
| Reasoning tokens | None. There is no decode | Billed as output tokens |
| Free tier | None documented | None |
| Prompt caching discount | Not documented | Yes |
| Batch discount | Not documented | Yes |
Jev rates from docs.typesafe.ai/models and the launch post, which words it as "FREE (too cheap to meter)". Nano rates from OpenAI's published API pricing, September 2026. Both vendors change prices. Check before you budget.
The row that matters is the third one. On Nano, a token written costs eight times a token read. On Jev, a token written costs nothing, because there is no token written: sampling is parallel across every question you declared rather than autoregressive. That single structural fact is what the rest of this page multiplies out.
Cost per 1,000 classifications
Three shapes of the same job. Assumptions first, so you can disagree with them specifically.
Shared assumptions:
- 1,000 items, one request each, no caching, no batching.
- Scenario A: 500 input tokens per item, roughly 350 of rubric and 150 of content. 40 output tokens for Nano: a small JSON object, no rationale, reasoning pinned to minimal.
- Scenario B: seven judgments about the same item, the shape the free scorer at /tools/will-it-go-viral uses. 850 input tokens per item, because seven rubrics are longer than one. 90 output tokens for Nano, one field per judgment.
- Scenario C: scenario A, but Nano spends 400 reasoning tokens before writing the 40 visible ones. Reasoning tokens bill at the output rate.
The multiplication, in full:
- A, Jev: 1,000 x 500 = 500,000 input tokens = 0.5M x $0.042 = $0.021. Output $0.00. Total $0.021
- A, Nano: 0.5M x $0.05 = $0.025. Output 1,000 x 40 = 0.04M x $0.40 = $0.016. Total $0.041
- B, Jev: 1,000 x 850 = 0.85M x $0.042 = $0.0357. Output $0.00. Total $0.036
- B, Nano: 0.85M x $0.05 = $0.0425. Output 1,000 x 90 = 0.09M x $0.40 = $0.036. Total $0.079
- C, Jev: unchanged at $0.021
- C, Nano: input $0.025. Output 1,000 x 440 = 0.44M x $0.40 = $0.176. Total $0.201
| Scenario | Jev | GPT-5 Nano | Nano / Jev |
|---|---|---|---|
| A. One label, 40 output tokens | $0.021 | $0.041 | 2.0x |
| B. Seven judgments, 90 output tokens | $0.036 | $0.079 | 2.2x |
| C. One label, 400 reasoning + 40 visible | $0.021 | $0.201 | 9.6x |
Arithmetic on published list prices. Your token counts will differ. The method is the point, not the totals.
Two honest readings of this table
On a bare label, Jev is about twice as cheap as Nano. That is a real win and it is not a reason to migrate anything on its own. The interesting number is scenario C, where Jev holds flat and Nano quintuples, because the variable is entirely on Nano's side of the ledger and it is not one you fully control.The same three numbers at volume
| Per 1,000 | Per 100,000 | Per 1,000,000 | |
|---|---|---|---|
| Jev, any of the three shapes above | $0.021 to $0.036 | $2.10 to $3.60 | $21 to $36 |
| Nano, scenario A | $0.041 | $4.10 | $41 |
| Nano, scenario B | $0.079 | $7.90 | $79 |
| Nano, scenario C | $0.201 | $20.10 | $201 |
Linear, because neither vendor offers volume tiers on these models. At a million items the rate limit becomes the binding constraint rather than the price. That math is on its own page.
A fair objection: at 100,000 items a month the whole argument is worth $2 to $16. Nobody moves a vendor for that. The gap earns attention when it compounds, and it compounds in one specific direction, which is the next section.
Why the eighth question is where the gap opens
Add a judgment to a Jev call and you pay for its rubric in the input budget and nothing else. Add a judgment to a Nano call and you pay for its rubric at $0.05 per million and for the field the model has to write at $0.40 per million. The marginal cost of a question is asymmetric by 8x on the half that grows with your ambition.
This is not a theoretical point. The free scorer at /tools/will-it-go-viral asks seven questions in a single 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. The reason seven questions is affordable is that six of them were free to answer.
TypeSafe calls this speculative fan-out and publishes a cookbook where batching 13 questions over one document ran 12.2 times cheaper and 10.0 times faster than the equivalent separate calls, with no change in the answers. That is the pattern the pricing is built around.
The same classification in both
One social post. Topic, from four options, plus a spam check. Jev first.
from typesafe_sdk import Choice, Noul, TypeSafeClient
client = TypeSafeClient()
response = client.system_one(
state=post_text,
model="jev-1.13.0",
questions={
"topic": Choice(
instructions="What is this post mainly about",
criteria={
"product": "A launch, a feature, a release",
"opinion": "A take or an argument",
"personal": "Life, travel, family",
"promo": "Asks the reader to buy, click or sign up",
},
),
"is_spam": Noul(instructions="This post is spam or an unsolicited advertisement"),
},
)
topic = response.answers["topic"]
print(topic.choice, topic.probabilities, topic.confidence)
print(response.answers["is_spam"].noul) # a float. No .confidence on a Noul.
print(response.usage.input_tokens) # what you are billed on
print(response.usage.output_tokens) # reported, but billed at zeroThen Nano, with strict structured outputs so the shape is guaranteed on that side too.
import json
from openai import OpenAI
client = OpenAI()
SCHEMA = {
"name": "post_triage",
"strict": True,
"schema": {
"type": "object",
"properties": {
"topic": {"type": "string", "enum": ["product", "opinion", "personal", "promo"]},
"is_spam": {"type": "boolean"},
},
"required": ["topic", "is_spam"],
"additionalProperties": False,
},
}
completion = client.chat.completions.create(
model="gpt-5-nano",
messages=[
{"role": "system", "content": RUBRIC},
{"role": "user", "content": post_text},
],
response_format={"type": "json_schema", "json_schema": SCHEMA},
)
answer = json.loads(completion.choices[0].message.content)
print(answer["topic"], answer["is_spam"])
# This is the line that decides your bill:
print(completion.usage.completion_tokens)
# Watch it in production. It is not a constant.The Noul field, because almost every third-party write-up gets it wrong
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 have one, because confidence is computed from a distribution and a Noul already is the distribution. Thresholding the float is how the docs tell you to turn it into a boolean.What price does not tell you
| Jev | GPT-5 Nano | |
|---|---|---|
| Published latency | 70ms to 500ms end to end, per TypeSafe | Not published. Varies with reasoning spend |
| Generates text | No, none at all | Yes |
| Probability over your options | Yes, covering every option, summing to 1.0 | Only via logprobs, only for single-token labels |
| Derived confidence | On Choice and Score. A Noul returns the probability itself | No |
| Image or audio input | No. Text only | On the multimodal variants |
| Context budget | 64k per request, 32k for state plus the longest question | Large, see the model card |
| Rate limits | 250,000 tokens/sec, 1,200 requests/min, adjusted dynamically | Per-account tier |
| Access | Early access waitlist. Or Vercel AI Gateway, OpenRouter, Cloudflare | Immediate, on an existing key |
| Self-host | No. Closed weights | No |
Jev column from docs.typesafe.ai, September 2026. Nano column from OpenAI's model card and pricing page.
On accuracy, the honest answer is that nobody knows
There is no published Jev versus Nano benchmark. TypeSafe's own four-workflow eval does not include Nano at all. Here is what it does include, so you can see the neighbourhood rather than a number invented for this page.
| Model | Workflow accuracy | Cost per case | Latency per case |
|---|---|---|---|
| Jev | 67.8% | $0.0004 | 0.4s |
| GPT-5.6 Terra | 67.9% | $0.0304 | 10.1s |
| Luna | 66.8% | $0.0033 | 12.9s |
| Claude Haiku 4.5 | 53.6% | $0.0195 | 12.5s |
| GPT-5 Nano | Not tested | Not tested | Not tested |
From evals.typesafe.ai, the vendor's own benchmark.
Read that table with four caveats attached, three of which TypeSafe states itself:
- There is no human ground truth anywhere in it. The reference labels are the average of GPT-6 Astra and Claude Fable 5.1. So 67.8 percent means Jev agrees with a two-model consensus about two thirds of the time, and 67.9 percent means Terra does too. Whether the consensus was right is a question the eval cannot answer.
- The workflows were written by TypeSafe's own team. Their words: "they were made by individuals on our model capabilities team, so some bias could exist."
- Jev does not lead on accuracy. It ties Terra and loses to Sol at 74.1 and Claude Opus 5 at 73.1. The pitch is comparable accuracy at a different price and latency, not superiority, and TypeSafe describes its own 193.6x and 444.6x headline figures as "on the higher end of real world gains."
- Nano is simply absent. Nothing in this table is evidence about Nano.
The only independent test so far is Mike Taylor's at Every: 777 judgments across 37 documents in under 0.7 seconds for an estimated quarter of a cent, running about 25 times faster and 580 times cheaper than Claude Fable 5.1 on the same passages. On planted defects Jev caught 6 of 7 where Fable 5.1 caught 7 of 7, and his own conclusion was that he would want a more thorough accuracy check before production, and that it works well "as an early warning system." That is the most useful sentence written about Jev so far.
Do the same thing on your own data. Two hundred labeled examples, both models, one afternoon. Then you have a number that is about your workload instead of somebody else's.
Which one to pick
Stay on GPT-5 Nano if
- The same call has to decide and write. Nano can, Jev cannot.
- You are under 100,000 items a month, where the gap is worth single-digit dollars.
- Images or audio are part of the input.
- Adding a vendor means a security review you do not want to run.
- Prompt caching already flattens your input bill.
- You are not on the Jev waitlist and do not want to route through a gateway.
Move the call to Jev if
- You ask several questions about the same text, so free output compounds.
- You want a probability over every option, not just the winning label.
- You need a bounded latency on a synchronous path.
- Your Nano completion_tokens graph is noisier than you would like.
- Volume is high enough that per-decision cost is a line item you defend.
- You already keep a separate LLM for the writing half.
Once it is classified, something has to ship it
Neither model posts anything. On the social side the last step is one request that fans out to three networks.
curl -X POST https://opentweet.io/api/v1/posts \
-H "Authorization: Bearer ot_your_key" \
-H "Content-Type: application/json" \
-d '{
"text": "Classified 40,000 replies this week. Here is what the topic split looked like.",
"publish_now": true,
"platforms": ["x", "bluesky", "linkedin"]
}'The same surface is exposed as a hosted MCP server, so an agent takes the same action. Get an API key or read the docs.
Frequently asked questions
Is Jev cheaper than GPT-5 Nano?
Yes, but by less than the headlines suggest, and how much less depends entirely on how many output tokens you let Nano produce. On a bare label with 500 input tokens and 40 output tokens, 1,000 classifications cost about $0.021 on Jev and about $0.041 on Nano. That is roughly 2x, not 400x. If you let Nano reason before answering, say 400 reasoning tokens on top of the 40 visible ones, the same 1,000 classifications cost about $0.201, which is roughly 10x Jev. Output tokens are the whole story, because Jev does not bill them at all.
What are the list prices?
Jev is $0.042 per million input tokens with output tokens unmetered, published on typesafe.ai and in the model docs. GPT-5 Nano is $0.05 per million input tokens and $0.40 per million output tokens on OpenAI's published rates. Note the shape of that: Nano's output rate is eight times its input rate, so every token Nano writes costs eight times what a token it reads costs. Jev's output rate is zero regardless.
Which one is more accurate?
Nobody has published a head-to-head, and anyone who tells you otherwise is guessing. TypeSafe's own four-workflow eval does not include Nano. The nearest published data points on that eval are Jev at 67.8 percent, GPT-5.6 Terra at 67.9, Luna at 66.8 and Claude Haiku 4.5 at 53.6. All of those numbers come from TypeSafe, the ground truth is the average of two other frontier models rather than human labels, and the workflows were written by TypeSafe's own model capabilities team, which the company acknowledges. Run both on 200 of your own labeled examples. That measurement takes an afternoon and beats every vendor table including this one.
Which one is faster?
TypeSafe publishes 70ms to 500ms end to end for Jev. There is no token-by-token decode. OpenAI does not publish a latency figure for Nano, and a nano-class reasoning model's latency depends heavily on how many reasoning tokens it spends, which varies per request. So the honest comparison is: Jev's latency is bounded by construction and Nano's is not. If you need a hard upper bound on a synchronous path, that difference matters more than the price difference.
Does GPT-5 Nano give me probabilities?
Only indirectly, through logprobs, and only when it works. Logprobs give you the log probability of each generated token plus a few alternatives at that position, so you can recover something distribution-shaped when your labels differ on their first token. It breaks on multi-token labels, on labels sharing a leading token, and when an option never enters the top-n shortlist. Jev returns probabilities over every option you declared, summing to 1.0, plus a derived confidence for Choice and Score. A Noul returns just the probability itself, a float from 0 to 1, with no separate confidence field.
What can GPT-5 Nano do that Jev cannot?
Write. Nano can summarise, rewrite, extract a free-form string, explain its own answer and handle image input on the multimodal variants. Jev produces no text of any kind, takes text only, has no self-host option, and is still waitlist-gated in early access. Nano also benefits from prompt caching and a batch API discount, neither of which TypeSafe documents. If your job needs one call that both decides and writes, Nano wins on architecture before you get to price.
When is the 2x price gap worth switching for?
Rarely on its own. At 100,000 classifications a month the difference between $2.10 and $4.10 is not a migration. The gap becomes a reason when it compounds with something else: you ask several questions about the same text so Jev's free output scales flat while Nano's scales linearly, you need a bounded latency on a hot path, or you want a probability to gate on rather than a label. If none of those apply, stay on the key you already have.
Keep reading
More arithmetic, more limits, and the part where the decision turns into a post.
Jev, explained for people who ship
What a System One model returns, and which launch claims survive a second look.
The cheapest way to classify a million posts
The same arithmetic at 1,000,000 items, plus the rate limit that decides your wall clock.
Jev vs OpenAI structured outputs
Both give you a schema-valid object. Here is the part that actually differs.
Jev cost calculator
Put your own token counts and volume in instead of trusting a worked example.
Will it go viral, a live Jev scorer
Free, no signup. Seven Jev questions on one draft, about 430 input tokens.
The OpenTweet API
One POST to /api/v1/posts publishes to X, Bluesky and LinkedIn.
Cheap decisions are only useful if something acts on them.
The Jev-powered scorer at /tools/will-it-go-viral is free and needs no signup. The publishing half starts at $11.99 a month, with the REST API and the MCP server on every plan.
- 7-day free trial
- No X developer account needed
- Cancel anytime