Jev Is Free Right Now: Where to Use TypeSafe AI's Jev Model Without Paying

Jev free access is real, but there is an important catch: Jev is not permanently free on every provider. Right now, developers can try the model without paying through promotional access on Vercel and through browser playgrounds, while providers such as OpenRouter expose the real model at an unusually low price of $0.042 per million input tokens with output free.

That makes Jev one of the easiest new AI models to experiment with. It also raises a question that many people are asking:

Who actually made Jev?

The answer is TypeSafe AI, a new company founded by former OpenAI researcher Diogo Almeida, alongside Sasha Sheng and Erik Gafni. Almeida says he co-invented RLHF and InstructGPT methods that contributed to the technology behind ChatGPT and GPT-4. Jev is not an OpenAI model, however. It is TypeSafe AI’s own model and the company’s first public “System One Model.”

What Is Jev?

Jev is not designed to replace ChatGPT, Claude, Gemini, GLM, or DeepSeek as a general-purpose chatbot.

TypeSafe built Jev for decisions inside software.

Instead of asking a model to generate a paragraph and then making your application parse the answer, you give Jev application state and a typed question. It returns a structured decision with probabilities.

For example:

State:
"The customer says their payment was charged twice."

Question:
"Which team should handle this?"

Choices:
Billing
Technical
Sales
Other

Jev can return a structured choice and confidence information that software can use directly.

TypeSafe calls the architecture System One, and says Jev uses a new model architecture, a parallel sampler, and a training method called Reinforcement Learning for Calibrated Decisions (RLCD).

That is why the model can be so fast and cheap: it is not spending inference time generating a long natural-language response when the application only needs a decision.

Who Made Jev?

This may be the most interesting part of the story.

Jev was created by TypeSafe AI, which came out of stealth in September 2026 after two years of development.

The founding team listed by TypeSafe is:

TypeSafe’s team page says Almeida co-invented RLHF and InstructGPT, while the company’s launch post says his earlier work at OpenAI contributed to the research behind ChatGPT. Sheng previously worked at Meta/FAIR, and Gafni has experience building production AI systems.

So when people say Jev was made by “a ChatGPT inventor,” there is a real connection, but the precise wording matters:

Jev is not made by OpenAI.

It is a TypeSafe AI model created by a team that includes a former OpenAI researcher whose work was part of the research lineage behind ChatGPT.

Why Did They Make Jev?

TypeSafe’s argument is that today’s language models are optimized for humans.

They generate strings:

• answers
• code
• explanations
• JSON
• tool calls
• refusals
• reasoning traces

Software then has to parse and validate those strings.

TypeSafe believes that many AI tasks do not actually need language generation.

A program might only need to know:

• Should I retry?
• Which agent should I call?
• Is this request risky?
• Should this support ticket go to billing?
• Is this code change likely to break production?
• Should a human review this?
• How urgent is this incident?

For those tasks, generating 500 tokens of prose is unnecessary.

Jev is designed to return the decision directly.

Where Can You Get Jev Free?

This is the most useful part for developers.

There are currently several ways to try Jev, but they are not equivalent.

The most important free API route right now is Vercel AI Gateway.

Vercel’s current TypeSafe model page lists:

typesafe-ai/jevFree

with:

• 32K context
• Free input
• Free output

Vercel’s model listing identifies it as a Jev release from September 15, 2026.

The Vercel promotion is temporary

An independent Jev access guide reports that Vercel’s free Jev promotion is scheduled to end September 25, 2026. Because that date is promotional rather than a permanent Jev pricing policy, check the Vercel model page before publishing a “free forever” claim.

That distinction is important for SEO accuracy.

A better headline is:

“Jev Is Free Right Now”

rather than:

“Jev Is a Permanently Free AI Model.”

Try Jev Free in a Browser

You do not necessarily need an API account just to understand what Jev does.

The Jev playground currently lets users run examples in a browser without a key or signup. The examples include support routing, moderation, lead scoring, code-review risk, and other decision tasks.

This is probably the easiest way for a developer who has never used Jev to understand why it exists.

The interaction is different from ChatGPT.

You are not asking:

“Explain this problem to me.”

You are asking:

“Make this specific decision for my software.”

Jev Free on Vercel AI Gateway

Vercel is currently the most interesting option if your goal is actual API experimentation without paying.

The normal Jev model is also available through Vercel’s AI Gateway, while Vercel’s current TypeSafe catalog separately lists typesafe-ai/jevFree with free input and output.

Jev can be called through Vercel’s AI SDK evaluation interface rather than a normal chat-completions workflow.

A simplified example looks like:

import { experimental_evaluate as evaluate } from "ai";

const result = await evaluate({
 model: "typesafe-ai/jev",
 state: "The customer was charged twice for the same order.",
 questions: {
 department: {
 type: "choice",
 instructions: "Which team should handle this?",
 criteria: {
 billing: "Payment, refund, or duplicate-charge issue",
 technical: "Software or product malfunction",
 sales: "New purchase or sales inquiry"
 }
 }
 }
});

console.log(result.answers);

The exact free model identifier and promotion can change, so developers should use the current Vercel model page rather than hard-code an assumption about promotional availability.

Is Jev Free on OpenRouter?

No.

OpenRouter currently lists Jev 1.13 at:

• $0.042 per million input tokens
• $0 per million output tokens
• 32K context

OpenRouter added Jev through its model catalog in September 2026. Because Jev produces structured decisions rather than ordinary chat text, OpenRouter exposes it through a dedicated decisions interface rather than treating it exactly like a normal chat model.

So OpenRouter is not the place to claim “free Jev.”

It is the place to say:

Jev is extraordinarily cheap.

At $0.042/M input tokens, one billion input tokens would cost about $42, with output not separately charged at the listed rate.

That is one of the central ideas behind TypeSafe’s business model.

Jev Free on Cloudflare

Cloudflare also exposes Jev as:

typesafe/jev

The Cloudflare documentation describes it as TypeSafe’s structured evaluation model and shows examples using Choice, Score, and Noul questions. It currently sends users to the Cloudflare dashboard for pricing rather than publishing a permanent free Jev API tier in the documentation.

So the safe description is:

Jev is available through Cloudflare AI Gateway, but Cloudflare should not currently be described as a permanently free Jev provider.

TypeSafe’s Own Jev API

TypeSafe is the original source of the model.

Its published pricing is:

TypeSafe says its pricing is designed for high-volume machine use rather than conventional chat. It also says the company cannot yet prove that its pricing is not subsidized and expects pricing to decrease rather than increase over time.

That is an unusually candid detail and worth mentioning in any Jev pricing article.

Jev vs OpenRouter vs Vercel vs Cloudflare

If the goal is simply “I want to try Jev for free,” the choices are different from the choices for production deployment.

The key distinction is:

Free to try does not mean free forever.

And:

$0.042/M does not mean the model is free.

Both statements matter if you are building an application around Jev.

Why Is Jev So Cheap?

This is where Jev gets technically interesting.

Normal LLMs generate text sequentially:

graph TD
 A["Application State"] --> B["LLM"]
 B --> C["Token 1"]
 C --> D["Token 2"]
 D --> E["Token 3"]
 E --> F["More Tokens"]
 F --> G["Parse Generated Text"]
 G --> H["Application Decision"]

Jev is designed around structured decisions:

graph TD
 A["Application State"] --> B["Jev"]
 B --> C["Choice / Score / Noul"]
 C --> D["Probability + Confidence"]
 D --> E["Application Branch"]

TypeSafe says Jev uses a parallel sampler, so multiple declared questions can be evaluated in parallel rather than generating a long sequence of tokens one after another.

That changes the economics.

If your application only needs:

retry = true

there is little reason to make a frontier model generate a paragraph explaining why.

Jev Is Not a Smaller ChatGPT

This is an important point.

Jev is not simply:

“a tiny LLM that is faster than GPT.”

TypeSafe describes System One models as a new class of model with:

• a new architecture
• a parallel sampler
• RLCD training
• typed outputs
• calibrated probabilities

The output space is deliberately constrained.

That constraint is a feature.

If the application says:

Choice:
billing
technical
sales

Jev cannot suddenly return:

I think this probably belongs to billing, although...

The software receives a defined decision type.

TypeSafe describes this as type safety rather than normal free-form generation.

Jev vs Frontier Models on RankLLMs Leaderboard

Jev should not be compared with frontier chat models as though they were identical products.

That means Jev can actually sit next to these models.

For example:

graph TD
 A["User Request"] --> B["Frontier LLM"]
 B --> C["Agent Plan"]
 C --> D["Jev"]
 D --> E["Should Continue?"]
 D --> F["Which Tool?"]
 D --> G["Is This Risky?"]
 E --> H["Workflow"]
 F --> H
 G --> H

The expensive model can reason about a complicated task.

Jev can handle thousands of small decisions around it.

That is arguably the more important Jev use case.

What Does “Zero Hallucinations” Mean?

TypeSafe uses strong language around Jev, including “zero hallucinations.”

The technical meaning is narrower than “Jev can never be wrong.”

Jev’s output schema is constrained, so the model cannot invent an output type outside the declared structure. TypeSafe says this is mathematically guaranteed by the schema.

But a valid decision can still be the wrong decision.

For example:

Question:
Is this customer message urgent?

Jev:
false
Probability:
0.91

The output is perfectly type-safe.

It could still be incorrect.

This distinction is critical for production systems.

Jev’s calibrated probability is designed to help software decide when to trust the result and when to escalate to a larger model or human. TypeSafe describes that as a central part of its System One approach.

Why Everyone Is Asking Who Made Jev

The founder story explains part of the attention.

Diogo Almeida’s background connects the company to some of the research that shaped modern instruction-following language models. TypeSafe’s own team page says he co-invented RLHF and InstructGPT and previously worked at Google Brain as well as OpenAI.

But TypeSafe’s thesis is almost the opposite of simply building another ChatGPT competitor.

Almeida’s launch post asks why models that are already extremely capable at conversation have not produced more automation.

His answer is that software needs a different interface.

Not:

“Give me some words.”

But:

“Make this decision, tell me how confident you are, and return it in a form my program can use.”

That is the idea behind Jev.

Is Jev Actually Free or Just a Promotion?

Right now, the accurate answer is:

Both, depending on what you mean by free.

There is a current Vercel promotional listing with free input and output. There are also browser playgrounds that allow free experimentation.

But the underlying Jev API is not a permanently free API. TypeSafe lists paid usage at $0.042/M input tokens, OpenRouter lists the same basic rate, and Cloudflare directs users to its dashboard for pricing.

The free Vercel offer is especially time-sensitive. An independent tracker currently reports an end date of September 25, 2026, so readers should verify the live Vercel listing before relying on it.

How to Use Jev for Free Right Now

If you only want to test the technology:

Option 1: Vercel

Use the current typesafe-ai/jevFree promotional listing if it is still available.

Option 2: Playground

Use a Jev browser playground to test Choice, Score, and Noul decisions without setting up an API key.

Option 3: Build cheaply

Use OpenRouter at $0.042/M input tokens and free output if you need an API and the Vercel promotion has ended.

Option 4: Cloudflare

If your application already uses Cloudflare AI Gateway, Jev is available as typesafe/jev; check the current dashboard pricing.

Option 5: TypeSafe

Use TypeSafe’s own API when you want the source-of-truth production route.

The Real Jev Opportunity

The interesting thing about Jev is not simply that people can get it for free for a few days.

It is that TypeSafe is testing a different assumption about AI software.

For years, developers have mostly treated the LLM as the brain and everything around it as glue code.

Jev flips part of that architecture.

The LLM can remain the expensive reasoning engine.

Jev can become the cheap, fast decision layer around it.

That could mean:

• routing between agents
• deciding whether to retry
• filtering bad tool calls
• scoring risk
• classifying users
• verifying outputs
• choosing a workflow branch
• deciding whether a human needs to intervene

And because Jev returns probabilities, software can use thresholds instead of blindly trusting every model answer.

Final Take

Jev is currently one of the easiest new AI models to try for free, but the free access is not the whole story.

The Vercel promotion gives developers a genuine opportunity to experiment without paying, while browser playgrounds make the model accessible without an API setup. OpenRouter and TypeSafe provide an extremely cheap paid route at $0.042 per million input tokens with output free, and Cloudflare exposes the model for applications already using its AI infrastructure.

But the bigger story is who made it and why.

Jev comes from TypeSafe AI, founded by Diogo Almeida, Sasha Sheng, and Erik Gafni. Almeida’s background includes work on RLHF and InstructGPT, but Jev is not an OpenAI model. It is TypeSafe’s attempt to build an AI interface designed for software rather than conversation.

And that is why Jev is worth watching.

The question is no longer only:

“Which AI model writes the best answer?”

Jev is asking a different question:

“What if software does not need an answer at all - what if it just needs a fast, calibrated decision?”

For developers, the fact that you can currently try that idea for free makes Jev particularly easy to test before spending anything.

Sources

• TypeSafe AI - Introducing System One Models & Jev
• TypeSafe AI - Team
• TypeSafe AI - Jev pricing
• Vercel AI Gateway - TypeSafe AI models
• Vercel - Jev model page
• Vercel - Jev launch
• OpenRouter - Jev 1.13
• Cloudflare - Jev
• Jev free playground / explanation