Skip to content
Today
Sign in

Published · 22h agoProduct7 min read

Jev prices classification at about four cents per million tokens

TypeSafe's Jev bills $0.042 per million input tokens and nothing for output, so a thousand thousand-token records cost about four cents to classify once. Simon Willison's tests show the answer arrives as a bare float.

6 publishersOperator

Not a builder's beat, but builders have a standing stake in it.See today for builders

Artwork accompanying Jev prices classification at about four cents per million tokens

What happened

  • Simon Willison published a post dated 21 September 2026 about Jev, which TypeSafe AI unveiled the previous week as the first example of a new category it calls "System One models"; Willison writes that "decision models" is a better name.
  • Jev accepts text inputs but instead of text output returns floating point numbers corresponding to categories, yes/no questions, ratings, and associated confidence scores. The caller composes a "state" object containing a string, array of strings, or set of name-value pairs and sends it with one or more questions.
  • Jev charges only for input, with output free, and the input price of TypeSafe's first model is $0.042 per million tokens, cheaper even than OpenAI's GPT-5 Nano at $0.05 per million.
  • TypeSafe describes Jev: "Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out."
  • Jev supports three question kinds: yes/no "Noul" questions returning a float between 0 and 1 (their CEO confirmed on Hacker News that Noul is short for Bernoulli), choice questions returning a confidence score plus a probability distribution across the options, and score questions returning a float along a range of numeric levels with descriptions.

Compiled by The Product DeskSomething wrong?How this is made

Why it matters

The same object, two bills

"Classify this feedback: The product is way too expensive." is the example sentence in the Transformers.js v4.3 release notes, and it comes back as the object {"sentiment": "negative", "topic": "price"} [15]. The new part of that release is an experimental, dependency-free package that constrains generation to a JSON schema, a JSON object, or a regular expression. A 350M-parameter ONNX model running on WebGPU in the browser can then only emit values from the enums you listed [14].

The same job now has a hosted price with a different shape. TypeSafe AI's Jev takes a state object and one or more questions and answers each with a floating point number: a yes/no confidence, a choice with a probability distribution across the options, or a score along numeric levels you describe [2][5]. TypeSafe's own framing is that you should "Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out." [4]

Simon Willison, writing on 21 September, reports Jev's input price as $0.042 per million tokens with output free, against $0.05 per million for OpenAI's GPT-5 Nano [1][3]. On input alone that is 16 per cent less [1]. Per batch the comparison is more useful: a thousand records of a thousand tokens each is exactly a million tokens, so one pass over that batch costs about four cents [2].

What four cents buys

Willison lists the work the model fits: anything expressible as a classification task, including spam detection, suggesting labels, prioritization and ranking [8]. He has been using it for search reranking, fetching 100 likely matches with BM25 and then scoring those candidates for relevance against the original query [9]. Questions are evaluated in parallel, so sending many should take about as long as sending one [6]. The Jev 1.13 jaggedness documentation says the model is currently not great with numbers, dates, or adversarial content [7].

What comes back is a float and a confidence score. Willison writes that if Jev marks something as spam, you do not learn which content signals tipped it off [10]. He stated the consequence directly: "I really hope nobody uses Jev to rank job applicants" [11]. His own probe scored Bay Area cities on a yes/no "Good city?" question, and it rated Cupertino top and East Palo Alto bottom [12].

So the price per decision is now small enough to disappear into a budget line. The work of finding the wrong decisions is unchanged. There is nothing in the response to inspect, so the check has to come from labelled examples you keep yourself.

Who pays for the local path

Transformers.js returns the same object without a per-token bill, and the constraint moves onto the device. Structured output currently supports one generated sequence at a time and needs a token budget large enough for the output to finish [16]. The release also turns on WebGPU for Safari 26 and above [17].

The cost you inherit is variance you cannot see from your own laptop. Hugging Face published 207 WebGPU kernels as individual versioned repositories [18]. Its argument for versioning that layer: two shaders that implement the same operation and produce the same output can behave completely differently across accelerators, with the best choice depending on input shape, device, browser and available WebGPU features [19]. Alongside the kernels it shipped Fleet, an in-browser benchmarking suite that collects correctness and performance evidence from users' own GPUs with their consent [20]. Willison's post does not point to an open-source implementation of Jev's interface, so a team that wants a second source for the same call has to assemble one from a local model.

Two teams that already count per item

Lovable is replacing Vite's development server with OJ, a Rust build tool written for the demands of running around one million short-lived development sandboxes per day [21]. In a controlled production rollout, the company reported median sandbox acquisition time falling from 14.5 seconds to 3 seconds and dev-server memory down roughly 6.5x [22]. Lovable engineer Jonathan Grahl said why memory is the constraint they optimise for: "Memory is a dedicated resource (compared to CPU which is highly shareable); which makes it expensive." [25] He said OJ's development server was idling at around 400 MB. He said Lovable hoped to push it lower so it could pack more sandboxes onto each host [26].

The synthetic figure runs well ahead of the production one. On a 10,000-component React app, bundled OJ used 115 MB against 1,751 MB for bundled Vite [23], about 15 times less [3], where the production rollout showed roughly 6.5x [22]. Cold start in that test was 1,315 ms for OJ and 1,528 ms for Vite, and hot module replacement was effectively even [23]. Vite creator Evan You called the earlier benchmark "somewhat misleading" because Vite has its own bundled development mode [24]. Lovable disclosed that one of its real-application comparisons ran vite-plugin-checker on the Vite side, a plugin that starts a TypeScript worker and that OJ does not support [27]. OJ creator Raphael Amorim was asked how much of the memory gap survives once the Node plugin host is running with a real vite.config. He said tests still showed OJ using less than one-third as much memory [28].

Linear's version of the same accounting began with an issue its CTO, Tuomas, assigned titled "CI costs are high" [32]. The team brought pull request wait time down from more than 6 minutes to just over 5 while its test suites almost quadrupled, and cut runner time per test roughly in half [29]. Those two numbers moved at different rates because they measure different things: the wait fell by about a minute, under 20 per cent [4], and it is set by the critical path, while runner time is total work. Capping fetch depth took the slowest change-detection gate from 94 seconds to 20, removing checkout from jobs that never needed a working tree took others from 27 seconds to 7, and none of the eight API test shards can start until those gates finish [30]. Moving workloads off GitHub Actions to third-party runners made jobs 34 per cent faster on average, with tsc down 52 per cent, and switching to tsgo cut the weekly median of the tsc check by 73 per cent [31].

The forcing function

Both teams named the unit before they optimised anything, and in both cases the bill has an owner: memory on a host for Lovable's sandboxes [25][26], runner minutes on a pull request for Linear [29]. For a classification feature the unit is an item decided, and the second number usually gets skipped: what it costs to find a wrong item.

Two axes, then. Per-item price against the cost of being wrong about one item. Cheap and reversible is where a price like $0.042 per million tokens decides on its own, and Willison's reranking setup over 100 BM25 candidates sits in that cell, because the next query is a free retry [3][9]. Cheap and hard to reverse is where the price stops mattering: a rejected applicant gets a float with no content signal behind it, which is what Willison's warning is about [10][11]. Expensive per item and reversible is the case for pushing the work into the browser, where the token bill is zero and the variance is the user's GPU [19]. Expensive and hard to reverse keeps a person in the loop, and the documented jaggedness on numbers and dates tells you which fields to keep away from the model [7].

The wrapper is worth writing because both interfaces have the same shape, a record plus a question set in and typed answers out [2][14], and what differs underneath is the bill and the failure mode. The clock can also sit somewhere other than the price list. Foxit's self-serve eSign provisioning hands you a Business trial that lasts 30 days and starts in TEST mode, so every envelope carries a watermark, and moving the account to Production is a Sales/Operations step performed in Foxit Monitor, not something the API can do [33].

The cheapest part of this project is the labelled set you check the output against. Willison reports that running hundreds or even thousands of experimental prompts through Jev costs just a few cents [13].

What to watch

  • Whether TypeSafe publishes any way to see which inputs moved a Jev score, given that today the API returns only floats and confidence values.

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [1]

    Simon Willison published a post dated 21 September 2026 about Jev, which TypeSafe AI unveiled the previous week as the first example of a new category it calls "System One models"; Willison writes that "decision models" is a better name.

    ReportedSource: Simon Willison, simonwillison.netView cited source
  2. [2]

    Jev accepts text inputs but instead of text output returns floating point numbers corresponding to categories, yes/no questions, ratings, and associated confidence scores. The caller composes a "state" object containing a string, array of strings, or set of name-value pairs and sends it with one or more questions.

    ReportedView cited source
  3. [3]

    Jev charges only for input, with output free, and the input price of TypeSafe's first model is $0.042 per million tokens, cheaper even than OpenAI's GPT-5 Nano at $0.05 per million.

    ReportedSource: Simon WillisonView cited source

Sources & coverage · 6 publishers

The reporting this story was synthesized from, earliest first. Every link goes to the original.

  1. huggingface.coAug 31
    Introducing @huggingface/kernels: 200+ WebGPU Kernels for Local AI
  2. linear.app3d ago
    AI coding has made CI a bottleneck, so we reworked ours to keep up
  3. github.com2d ago
    Transformers.js v4.3: Run AI Models in the Browser
  4. socket.dev2d ago
    disputes the benchmark
  5. developer-api.foxit.com2d ago
    A developer's guide to adding eSignature to your app with an API
  6. simonwillison.net2d ago
    writes about Jev

    Cited in this coverage: Simon Willison, simonwillison.net

Additional citations

  • Simon Willison
  • TypeSafe AI, quoted by Simon Willison
  • Lovable, reported by Socket
  • Evan You, Vite creator, quoted by Socket
  • Jonathan Grahl, Lovable engineer, quoted by Socket
  • Jonathan Grahl, quoted by Socket
  • Raphael Amorim, OJ creator, via Socket