Jev OpenAI Connection: Is Jev Made by OpenAI, and How Do They Compare?

The headline said "a ChatGPT inventor". The benchmark charts put Jev next to GPT models. A Vercel engineer described swapping an OpenAI model out for it. So when a new AI model called Jev showed up everywhere in September, a lot of people reasonably assumed it was OpenAI's — and searched Jev OpenAI to find out.

It isn't. Jev is made by TypeSafe AI, a separate San Francisco company. The connection is real, though: TypeSafe's founder spent years at OpenAI building the training method behind ChatGPT, and Jev was designed as a direct answer to what he thinks that method gets wrong. (If you were looking for JEV in a medical context, that is the Japanese encephalitis virus — a different subject entirely.)

We run jev-ai.org, a playground and API built on the Jev model. This guide draws on TypeSafe's own launch post and documentation, OpenAI's API documentation, and launch coverage from TechCrunch and SiliconANGLE. By the end you will know exactly how Jev and OpenAI are connected, where Jev's advantage over a GPT model is real and where it is not, and how to run the two side by side in one workflow.

Last updated September 30, 2026. Both companies ship fast; model names and prices below are as published on that date.

Is Jev Made by OpenAI? The Short Answer

No. Jev is the first model from TypeSafe AI, released in early access on September 15, 2026. OpenAI did not build or release it, and it is not one of the models offered in OpenAI's API or ChatGPT. What links the two is a person: TypeSafe's co-founder and CEO, Diogo Almeida, previously worked at OpenAI on the research behind ChatGPT. If you want the basics of the model itself first, start with what Jev AI is.

Where the Jev–OpenAI Connection Comes From

Four separate threads tie Jev to OpenAI, and each one explains a different part of the confusion.

1. The founder came from OpenAI

TypeSafe's team page credits Almeida with co-inventing RLHF (reinforcement learning from human feedback) and InstructGPT, "the methods that lead to ChatGPT and GPT4". SiliconANGLE describes his OpenAI work as spanning RLHF, InstructGPT, ChatGPT and GPT-4. TechCrunch reports he left OpenAI about two years before Jev launched and started TypeSafe with co-founders Erik Gafni and Sasha Sheng. Our profile of TypeSafe AI covers the company, its funding and its team in full.

2. Jev is a reaction to the method behind ChatGPT

Almeida's argument, repeated across TypeSafe's launch post and interviews, is that RLHF made models superb at pleasing people and poor at running unattended. "We have lightning in a bottle, and yet it is not useful," he told TechCrunch. Jev's training method, RLCD, replaces human preference with calibration. So Jev is not an OpenAI model — it is closer to a counter-argument to one.

3. TypeSafe benchmarks against OpenAI models

TypeSafe's launch materials measure Jev against OpenAI's current models by name. Its side-by-side speed demo runs the same query against GPT-5.6 Terra with default reasoning, and its workflow evaluations use the average of GPT-6 Astra and Anthropic's Fable 5.1 as the reference answer. SiliconANGLE reports that TypeSafe's website lists Jev at 39 cents per 1,000 workflows against $3.31 for OpenAI's GPT-5.6 Luna.

4. Early customers swapped OpenAI models out

The most-quoted early result involves an OpenAI model. According to TechCrunch, Vercel had been using OpenAI's Luna 5.6 as a classifier that reviews commands for safety; replacing it with Jev returned results five to 18 times faster, with greater accuracy.

Put those four together and "Jev OpenAI" is a natural search. The answer to it is simply that the connection runs through a person and a rivalry of ideas, not through ownership.

Jev vs OpenAI Models: What Is Actually Different

This is where most comparisons get lazy. The honest version has one surprise in it.

The surprise: type safety alone is not unique to Jev. OpenAI's API offers Structured Outputs, which OpenAI describes as ensuring "the model will always generate responses that adhere to your supplied JSON Schema" — including never hallucinating an invalid enum value. So "Jev can't return the wrong type and GPT can" is not true for a well-configured GPT call.

What is different is everything around the answer:

Rule of thumb: the reason to pick Jev over a GPT model is not that its answers are well-formed. It is that its answers come with an honest number you can put a threshold on, and that the answer is cheap and fast enough to ask on every event instead of a sample.

Is Jev Better Than OpenAI's Models?

At what? That is the whole answer, but here is the evidence behind it.

Where the evidence favours Jev. On narrow decisions — routing, classification, grading, guardrails — the reported gains are large. Vercel's safety-classifier swap is the clearest outside data point. TypeSafe's own workflow evaluations put Jev at up to 193.6 times faster and 444.6 times cheaper than frontier LLMs.

Where to be careful. Those multipliers are TypeSafe's own numbers, from workflows its capabilities team wrote. The launch post says they are "on the higher end of real world gains" and that using GPT-6 Astra and Fable 5.1 as the reference biases scores toward OpenAI and Anthropic models; SiliconANGLE notes they have not been independently verified. And accuracy is not a one-way street: in another developer's test reported by TechCrunch, Gemini classified business emails slightly more accurately than Jev, though at 10 to 20 times the cost.

Where OpenAI wins outright. Anything a person reads. Jev cannot write a reply, a summary, a translation, code or an explanation. TypeSafe's own docs are blunt that Jev is not a drop-in replacement for the model behind a coding agent: there is no setting that turns a coding assistant into a Jev-powered one.

So the useful question is not "Jev or OpenAI?" It is "which parts of my workflow are decisions, and which are writing?"

How to Use Jev With OpenAI

The pattern that works best is a division of labour: Jev decides, a GPT model writes. Three ways to wire it:

1. Jev as the gate. Classify every incoming request with Jev first, and only call a GPT model for the cases that genuinely need a written answer. The expensive model runs less often, and only on inputs you have already routed.
2. Jev as the checker. After a GPT model answers, ask Jev whether the answer is grounded in the source, on-topic and safe. A noul with a threshold is a guardrail you can run on every response — see our RAG evaluation page for the citation-check version.
3. Jev as the router. Ask Jev which model, or which reasoning effort, a request needs, and send it there — the idea behind our LLM router. OpenRouter now lists a "TypeSafe: Jev Router" that it describes as picking the best model and reasoning effort for each request, running on Jev.

Example: Jev triages, OpenAI drafts

Here is the gate pattern in Python. Jev reads a support ticket and answers two typed questions through the jev-ai.org API; only a ticket that is confidently routed and does not need a person goes on to OpenAI's Responses API for a draft reply.

import os

import requests
from openai import OpenAI

ticket = (
    "We were billed $49 twice on September 3. I opened ticket #4417 four days "
    "ago and have had no reply, and our books close on Friday."
)

# 1. Jev decides: one call, two typed questions, probabilities back.
decision = requests.post(
    "https://jev-ai.org/api/v1/systemone/",
    headers={
        "Authorization": f"Bearer {os.environ['JEV_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "jev-1.13",
        "state": ticket,
        "questions": {
            "needs_human": {
                "type": "noul",
                "instructions": "Does this ticket need a human reply rather than an automated one?",
            },
            "queue": {
                "type": "choice",
                "instructions": "Route this ticket to the team that should own the first reply.",
                "criteria": {
                    "billing": "Invoices, refunds, duplicate charges, plan changes, tax.",
                    "technical": "API errors, integrations, outages, SDKs.",
                    "sales": "Pre-purchase questions about plans, limits or trials.",
                },
            },
        },
    },
    timeout=10,
).json()

needs_human = decision["answers"]["needs_human"]["noul"]
queue = decision["answers"]["queue"]

# 2. Your code acts on the numbers.
if needs_human > 0.8 or queue["confidence"] < 0.8:
    print("Send to a person:", queue["choice"], round(needs_human, 2))
else:
    # 3. OpenAI writes, only for the cases that need writing.
    client = OpenAI()
    response = client.responses.create(
        model="gpt-6-astra",
        input=f"Draft a short, polite first reply from our {queue['choice']} team to this ticket:\n\n{ticket}",
    )
    print(response.output_text)

A few notes on the code:

• The Jev request body is the one in our API docs, unchanged; only the two question ids your code reads matter.
• The OpenAI half follows OpenAI's own quickstart: client.responses.create(...) and response.output_text. Swap in whichever GPT model you already use.
• On this particular ticket — a double charge, an unanswered ticket and a deadline — Jev is likely to say a person should reply, which is exactly the point: the draft step only runs when it is safe to automate.

Can I call Jev with the OpenAI SDK?

Not for decisions. Jev is not a chat-completions model, so pointing chat.completions.create at it will not work. Call the decision endpoint over plain HTTP, as above, or use TypeSafe's official Python and JavaScript SDKs against TypeSafe's own API. On jev-ai.org, the model listing at /api/v1/models/ does use OpenAI-style model objects, so a client that only understands those still sees each model's id, object, created and owned_by.

Measure before you switch

TypeSafe publishes an open-source System One Adapter that runs the same typed questions against an LLM instead of Jev, so you can compare cost, speed and answers on your own data. Its README example sends one question to an OpenAI model:

from system_one_adapter import SystemOneAdapterClient, Noul, Score, Choice

client = SystemOneAdapterClient(
    structured_outputs=True,  # use the provider's native structured-output mode
    llm_answer_mode="probabilities",  # or "discrete"
    normalize_probabilities=True,
)

response = client.system_one(
    state="This book was a delight to read.",
    questions={"positive": Noul(instructions="The book review is positive.")},
    provider="openai",  # "openai", "anthropic", or "gemini"
    model="gpt-4o-mini",
)

Install it with pip install 'system-one-adapter[openai]'. Run a few hundred of your real inputs through both, and you will know whether the switch is worth it before you change any production code.

The low-effort version of that test needs no code at all. Open the Jev AI playground, paste in a ticket, review or answer your GPT model currently classifies, and compare Jev's answer — and its probabilities — with what you get today. Sign in for five free credits; no card and no waitlist.

Should You Replace an OpenAI Model With Jev?

Decide job by job, not model by model.

Rule of thumb: if the output ends up in an if, a queue name or a database column, test Jev on it. If a person is going to read it, keep the GPT model — and consider putting Jev in front of it to decide when it runs.

FAQ

Is Jev owned by OpenAI?

No. Jev is owned and served by TypeSafe AI, a separate company that raised a $40 million seed round led by DCVC.

Did an OpenAI co-founder create Jev?

No. Diogo Almeida was an OpenAI researcher, not one of OpenAI's founders. TypeSafe credits him with co-inventing RLHF and InstructGPT; he co-founded TypeSafe AI in 2024.

Does Jev use an OpenAI model under the hood?

TypeSafe has not published Jev's architecture or base model. TechCrunch reports that outside observers suspect it is built on an open-weight LLM, which the company has not confirmed. Nothing public indicates an OpenAI model. Our guide to how Jev works covers what has and has not been disclosed.

Is Jev available in ChatGPT?

No. Jev is not a chat model, so there is nothing to select inside ChatGPT. It is served through TypeSafe's API and console, and through third-party platforms such as jev-ai.org.

Is Jev cheaper than OpenAI?

For decisions, usually by a wide margin: TypeSafe's list price is $0.042 per million input tokens with free output, and in our own tests a multi-question call cost two to four thousandths of a cent. OpenAI prices vary by model. For writing tasks the comparison does not apply, because Jev cannot do them.

Can I use Jev and OpenAI together?

Yes, and that is where Jev earns its place: let Jev decide what happens — route, check, escalate — and let a GPT model write when writing is needed.

The Bottom Line

Jev is not an OpenAI model, but it would not exist without OpenAI: it is what one of the people behind ChatGPT built after deciding chat was the wrong interface for automation.

• Jev is made by TypeSafe AI; the OpenAI link is its founder's research history.
• Both can guarantee an answer's shape; only Jev returns a calibrated probability for every option, in parallel, with output billed at zero.
• The biggest published speed and cost multipliers are TypeSafe's own and come with stated biases; the Vercel swap is the strongest outside evidence.
• Jev cannot write anything. The best setup uses it to decide and a GPT model to write.

Pick one decision your GPT model makes today and run it through Jev. Try it in the playground, then send the same request through the Jev AI API once the numbers convince you.

Sources

• A new kind of AI model from a ChatGPT inventor is thrilling developers — TechCrunch — Almeida's OpenAI background, the Vercel and Bryo results, the unpublished architecture.
• Introducing System One Models & Jev — TypeSafe AI — RLCD vs RLHF, pricing, latency, and the OpenAI reference models behind the benchmark claims.
• TypeSafe AI exits stealth with $40M — SiliconANGLE — Funding, founders and the GPT-5.6 Luna cost comparison.
• Structured model outputs — OpenAI API docs — What OpenAI guarantees about schema adherence.
• System One Adapter — TypeSafe AI on GitHub — Running the same typed questions against OpenAI and other LLMs for comparison.

Model names, prices and benchmark figures are as published on September 30, 2026. Performance multipliers are vendor-reported unless stated otherwise; test on your own data before switching production traffic.