Jev Launched Monday. Six Community Repos Existed by Wednesday.

TypeSafe AI came out of stealth on September 15 with Jev. The model does not generate text at all. You hand it unstructured state plus a list of typed questions. It returns typed answers with confidence scores attached. No prose, no code, no explanation. Founder Diogo Almeida co-authored the InstructGPT paper behind ChatGPT. The launch came with a $40 million seed led by DCVC. Two days later six community repos exist on GitHub, five of them MIT, built by people who are not TypeSafe. One puts Jev on a trading pair. Another does computer use for about $0.0002 a step. The speed claims come with caveats TypeSafe published themselves, which almost no coverage repeated. Best for developers with classification or routing sitting in a hot path. Not ideal for anything needing text out the other end.

Jev came out of stealth on Monday.

By Wednesday morning there were six community repos built on it. None of them from TypeSafe.

One runs a trade decision every Monad block. Another plays Super Mario Bros from emulator state. A third does computer use for about two hundredths of a cent per step. All created inside 48 hours, five of the six under MIT.

Most launches get coverage. Very few get an ecosystem before the press cycle finishes.

What Jev Actually Is

Figures below come from TypeSafe’s own documentation plus launch coverage, checked September 17.

That second-to-last row costs more than it looks. More on it below.

A Model That Refuses to Write

Every model you have used generates strings one token at a time. Jev does not do that.

What goes in and what comes out

You give it a piece of state. An email, a log line, a support ticket, a blob of JSON holding game coordinates. Alongside it you give a list of typed questions.

It returns typed answers. A choice from a set you supplied, a score against a rubric, or a yes-no probability. Each answer carries its own confidence value. No prose wrapped around it, no explanation, nothing to parse.

Almeida describes it as a frontier-intelligence function call. Unstructured state in, typed probabilistic decisions out.

Why that removes a whole layer

Anyone who has shipped an LLM into production knows the tax. It returns text, so you write a parser. That parser breaks on edge cases, so you add a validator. Malformed output still slips past, so you wrap it in a retry loop. Then you add guardrails because the model occasionally invents a category that does not exist.

Jev is constrained to the schema you defined, so it cannot return a value outside it. TypeSafe’s phrasing is that it gives up string generation in exchange for structured outputs that cannot hallucinate.

That claim is narrower than it sounds. Jev cannot return a category you did not define. It can still pick the wrong one from the list you gave it.

The parallel sampler

Rather than producing values one after another, Jev evaluates all the structured values it needs simultaneously through a hardware-aware parallel sampler.

That design is why the output tokens are free. There is no token stream to meter on the way out.

The Doom demo, briefly

TypeSafe shipped a Doom bot running at 10 queries per second for roughly $7 an hour, plus a Wikiracing traversal that finishes in fewer steps than its comparisons.

Games are a sensible demo for this because the state is already structured. Enemy positions, health, ammo count, available exits. No parsing required, so the model gets exactly the shape of input it was built for.

That also explains typesafe-mario appearing within a day. Somebody saw the Doom demo, noticed emulator state is equally structured, then pointed it at a different game before the week was out.

The uncomfortable read is that games flatter this architecture. Real production state is messier than a frame of Doom, plus the demos do not tell you how calibration holds up on a support ticket written by an angry customer at midnight.

RLCD Is the Research Claim

TypeSafe calls its training method Reinforcement Learning for Calibrated Decisions, positioning it as a third path alongside two you already know.

The three paths

RLHF, reinforcement learning from human feedback, optimises for answers people like. It is what made ChatGPT feel like an assistant, plus Almeida helped build it.

RLVR, reinforcement learning with verifiable rewards, optimises for outputs a program can check. Maths problems, code that compiles, anything with a right answer.

RLCD optimises for calibration. The goal is that when Jev says it is 80% confident, it turns out correct about 80% of the time.

Why calibration matters for software

A chat assistant can give you a confident wrong answer plus you will usually notice. Software cannot. If your routing logic acts on a confidence score, that score needs to mean something numerically rather than rhetorically.

Automation needs uncertainty that can govern behaviour. Reassuring language is not that.

The problem with evaluating it

As of the launch, TypeSafe has described what RLCD is meant to do without publishing enough for anyone to evaluate it as an algorithm.

So the central research claim sits unverifiable for now. TypeSafe does tell you to test confidence thresholds against your own labelled examples rather than trusting theirs, which is more honest than most launches manage.

The Six Repos

Every figure below came through the GitHub API on the morning of September 17.

What people built

jev-trader took 366 stars in its first day with 75 forks behind it, MIT, TypeScript. It makes one trade decision every Monad block on a MON-USDC pair.

typesafe-mario hit 168 stars playing Super Mario Bros from structured emulator state. No licence file, so it fails any reuse test.

typesafe-computer-use reached 145 stars, MIT, Python. It OCRs the screen then classifies the next action, costing roughly $0.0002 per step.

jev-review at 81 stars is a staged code-review workflow with a local dashboard. foreman at 75 stars is a software factory orchestration layer. A second jev-review at 47 stars is a local-first MCP plugin for continuous quality review.

The fork ratio on day one

jev-trader carries 75 forks against 366 stars. That is roughly one in five people cloning it within 24 hours of the repo existing.

We started tracking fork ratios in Fresh Commits because stars cost a click while forks cost intent. A 20% ratio on day one is higher than anything in that week’s roundup.

What the spread says

Trading, games, computer use, code review, orchestration. Nobody coordinated that, plus none of those builders work for TypeSafe.

The common thread is that all five categories involve a decision in a loop. Something happens, a system classifies it, then acts. That is precisely the shape Jev was built for, so developers found the fit immediately rather than needing to be told.

What “System One” Is Borrowing From

The category name is doing deliberate work, so it deserves unpacking.

The reference

System One and System Two come from behavioural psychology, describing fast automatic judgement against slow deliberate reasoning. Recognising a face is System One. Working through a tax return is System Two.

TypeSafe is arguing that the industry built System Two machines then wired them into System One jobs. A frontier model reasoning its way through whether a support ticket is a billing question is doing deliberate work on a task that needs reflex.

Where the analogy helps

It explains the latency target. Seventy milliseconds is roughly the speed at which a decision can sit inside a loop without anyone noticing it happened. Three seconds is not.

It also explains the missing explanation. System One judgements do not come with reasoning attached, which is why Jev returns a confidence value rather than a paragraph defending itself.

Where the analogy strains

Human System One is famously unreliable. It is where bias lives, plus where confident wrong answers come from.

TypeSafe’s whole calibration pitch is that their version knows when it is unsure, which is precisely what human fast thinking fails at. So the name describes the speed while promising the opposite of the failure mode.

Marketing rather than architecture, though it is a useful frame for deciding which jobs to hand it.

The One With No Licence

Five of the six community repos ship MIT. typesafe-mario does not.

Why that matters at 168 stars

No licence file means default copyright, with all rights reserved to the author. You cannot legally fork it, modify it or build on it, whatever the README implies.

At 168 stars in a day it is the second most popular thing built on Jev so far, plus it is the one nobody can legally reuse.

The recurring pattern

We found the same thing running Fresh Commits, where three of the week’s fastest climbers carried no usable licence. Roughly a third of what trends in this category each week fails that check.

Nothing suggests bad faith. Somebody shipped a fun weekend project at 2am and never thought about redistribution rights, which is completely normal. The cost lands on everyone downstream who assumes a popular repo is safe to build on.

Check before you clone. It takes ten seconds.

What the Speed Numbers Actually Compare

Here is where coverage got lazy, plus TypeSafe deserves some credit for the thing everyone skipped.

The headline figures

Workflow evaluations produced results up to 193.6 times faster along with 444.6 times cheaper than the comparison systems. Latency of 70 to 500 milliseconds against 3 to 329 seconds on chat deployments.

Those are large enough numbers to carry a launch, which is what they did.

The three caveats TypeSafe published themselves

The workflow authors came from TypeSafe’s model-capabilities team. TypeSafe flags this as possible bias, since the people designing the tests also build the product.

The reference answers were averages taken from GPT-6 Astra plus Fable 5.1. So the benchmark is scored against what two frontier chat models produced rather than against ground truth.

The competing language models were constrained through TypeSafe’s own structured-output wrapper. TypeSafe says that wrapper is accurate while being slower plus more expensive than simply asking those models for decisions without probabilities.

Why that third one does the most damage

Read it again. The comparison models were slowed down by a wrapper TypeSafe built, which TypeSafe admits is slower than the alternative approach available to those models.

A 193.6x speedup measured against a deliberately handicapped baseline is not the same claim as 193.6x faster than the alternatives. TypeSafe said so plainly in their own material. Almost nobody quoted it.

That is not an accusation of dishonesty. Disclosing your own methodology problems is the opposite of dishonest. It does mean the number in the headlines is softer than the headlines suggest.

What It Costs

Pricing is where Jev stops being an architecture argument.

The numbers

$0.042 per million input tokens. Output tokens are free, because the parallel sampler produces no output stream to meter.

For comparison, running a frontier chat model over the same classification volume costs orders of magnitude more, plus you pay for the output tokens that carry the explanation you did not want.

What that unlocks

The Doom demonstration runs at 10 queries per second for roughly $7 an hour. typesafe-computer-use lands around $0.0002 per step.

At those prices you can put a model in places that were previously rule-based because inference was too expensive to sit in the loop. Fraud checks on every transaction. Routing on every support ticket. Classification on every log line.

That is a different deployment envelope from what a Claude Pro subscription or any per-seat chat plan is designed for. Different tool, different job.

The Limits Nobody Lists

Launch coverage carried the speed figures. It mostly skipped the constraints, which decide whether you can use this.

It is not a drop-in

Jev does not follow the OpenAI chat-completions convention. You cannot point an existing client at a new base URL, so integration means a bespoke client rather than a config change.

For anyone whose stack assumes OpenAI-compatible endpoints, that is a real piece of work rather than an afternoon.

The context budget is small

Roughly 32,000 tokens per request, described in TypeSafe’s docs as about 150,000 English characters.

That is fine for a support ticket or a log line. It rules out anything involving a long document, a full codebase or an extended conversation history.

No images, no audio

Text plus structured state only at launch. Any workflow starting with a screenshot needs OCR in front of it, which is exactly what typesafe-computer-use does.

Access is gated

Early access waitlist plus a browser playground. The model alias is jev-latest. TypeSafe has begun onboarding engineering teams from a deployment waitlist rather than opening it fully.

So the six repos on GitHub were built by people who got in early. That is worth holding in mind when reading the adoption curve, because a gated launch producing this much output means TypeSafe chose the right early users rather than that the door is open to everyone.

Why the Ecosystem Moved This Fast

Six repos in 48 hours needs explaining, since most launches produce nothing.

The demos were buildable, then copied

TypeSafe shipped with a Doom bot plus a Wikiracing traversal. Both are small, legible, reproducible projects rather than enterprise case studies.

Developers saw something they could copy the shape of in an evening. typesafe-mario is visibly that impulse, taking the Doom idea then pointing it at a different emulator.

The price made experiments free

At $0.042 per million input tokens with no output metering, a weekend project costs pennies. Nobody had to ask permission or estimate a budget.

Cheap enough to try without thinking is its own adoption strategy, plus it works far better than a free tier with a credit card wall in front of it.

Compare that to how most model launches go. A waitlist, a pricing page built for procurement, then a quiet six months while nobody builds anything because nobody can estimate what a prototype will cost.

The category was already waiting

Everyone shipping agents has been writing structured-output plumbing by hand. Parsers, validators, retry loops, guardrails. We saw the same pattern when agent skills became a vendor channel, where the format spread because it solved a problem people were already solving badly.

Jev landed on an existing pile of frustration. That timing does more than the architecture does.

What You Should Actually Do

If you have classification in a hot path

This is the case worth testing. Ticket routing, content moderation, fraud scoring, log triage, anything where a chat model is overkill plus rules are too rigid.

Get on the waitlist, then run the browser playground against your own labelled examples before committing. TypeSafe explicitly says confidence thresholds are use-case-specific, so their calibration numbers tell you nothing about your data.

If you are running agents

Look at where your agent makes small decisions between big ones. Which tool to call, whether output passed, which branch to take. Those are Jev-shaped.

The harness argument from our Hermes piece applies here. A cheap fast model handling the routing while a frontier model does the reasoning is a sensible split, plus it is what the cost difference pushes you toward.

If you want text out

Skip it entirely. Jev does not generate strings. There is no configuration that makes it write for you, so it does not compete with anything in our three-way model comparison.

If you are just curious

Read typesafe-computer-use rather than the launch blog. It is a small MIT repo showing what the model does inside a real loop, which teaches more in ten minutes than the benchmark table does.

The Part Worth Keeping

Six repos in two days from people with no connection to the company.

That has nothing to do with the benchmark figures, which came with three caveats TypeSafe wrote down themselves plus almost nobody repeated. Adoption happened because the demos were copyable, the price made failure free, plus a lot of developers were already hand-writing the plumbing this replaces.

The research claim behind it stays unproven. RLCD has been described rather than published, so calibration is a promise until somebody outside TypeSafe measures it against their own labelled data.

Both things are true at once. A model with an unverifiable core claim now has a working ecosystem. That ecosystem arrived because the thing is cheap and easy to try rather than because anyone checked the maths.

Run it against your own examples. Their confidence numbers describe their data, not yours.

Charts and Blocks

Community repos built on Jev in 48 hours

Jev against a chat model for the same job