---
title: "Jev: The ChatGPT Co-Creator's System One Model Can't Talk"
description: "TypeSafe AI's Jev is a System One model that decides instead of talking: 70-500ms, $0.042/MTok, output free. Diogo Almeida's RLHF led to ChatGPT."
canonical: https://lukeocodes.dev/jev-system-one-model
type: article
locale: en_GB
published: 2026-09-17T00:00:00.000Z
modified: 2026-09-17T00:00:00.000Z
authors:
  - Luke Oliff
section: AI
tags:
  - AI
  - Industry
  - Opinion
  - jev
  - typesafe ai
  - diogo almeida
  - rlcd
  - system one models
  - model release
feed: https://lukeocodes.dev/rss.xml
search: https://lukeocodes.dev/search.json?q={query}
schema:
  - "@context": https://schema.org
    "@graph":
      - "@type": Organization
        "@id": https://ably.com/#organization
        name: Ably
        url: https://ably.com
      - "@type": WebSite
        "@id": https://lukeocodes.dev/#website
        url: https://lukeocodes.dev
        name: Luke Oliff
        alternateName: lukeocodes
        inLanguage: en
        publisher:
          "@id": https://lukeocodes.dev/authors/luke#person
        description: Personal blog and writing by Luke Oliff — developer relations, voice AI, developer experience.
        potentialAction:
          - "@type": SearchAction
            target:
              "@type": EntryPoint
              urlTemplate: https://lukeocodes.dev/blog/search?q={search_term_string}
            query-input: required name=search_term_string
      - "@type": Person
        "@id": https://lukeocodes.dev/authors/luke#person
        name: Luke Oliff
        url: https://lukeocodes.dev/authors/luke
        description: Staff engineer and Staff Tech Lead for Developer Experience at Ably. Writing about developer relations, AI, and the voice industry, from the UK.
        mainEntityOfPage: https://lukeocodes.dev/authors/luke
        givenName: Luke
        familyName: Oliff
        image: https://lukeocodes.dev/authors/luke.jpg
        jobTitle: Staff Tech Lead, Developer Experience
        worksFor:
          "@id": https://ably.com/#organization
        sameAs:
          - https://www.linkedin.com/in/lukeocodes
          - https://github.com/lukeocodes
          - https://bsky.app/profile/lukeocodes.dev
          - https://x.com/lukeocodes
          - https://hashnode.com/@lukeocodes
          - https://dev.to/lukeocodes
        knowsAbout:
          - Developer Relations
          - Developer Experience
          - Voice AI
          - Text-to-Speech
          - Answer Engine Optimisation
          - Search Engine Optimisation
          - Open Source
          - Developer Tooling
          - API Design
          - Speech-to-Text
          - Voice Agents
          - Community Building
        knowsLanguage:
          - English
        nationality: British
        alumniOf:
          - "@type": Organization
            name: The Open University
  - "@context": https://schema.org
    "@graph":
      - "@type": Organization
        "@id": https://ably.com/#organization
        name: Ably
        url: https://ably.com
      - "@type": Person
        "@id": https://lukeocodes.dev/authors/luke#person
        name: Luke Oliff
        url: https://lukeocodes.dev/authors/luke
        description: Staff engineer and Staff Tech Lead for Developer Experience at Ably. Writing about developer relations, AI, and the voice industry, from the UK.
        mainEntityOfPage: https://lukeocodes.dev/authors/luke
        givenName: Luke
        familyName: Oliff
        image: https://lukeocodes.dev/authors/luke.jpg
        jobTitle: Staff Tech Lead, Developer Experience
        worksFor:
          "@id": https://ably.com/#organization
        sameAs:
          - https://www.linkedin.com/in/lukeocodes
          - https://github.com/lukeocodes
          - https://bsky.app/profile/lukeocodes.dev
          - https://x.com/lukeocodes
          - https://hashnode.com/@lukeocodes
          - https://dev.to/lukeocodes
        knowsAbout:
          - Developer Relations
          - Developer Experience
          - Voice AI
          - Text-to-Speech
          - Answer Engine Optimisation
          - Search Engine Optimisation
          - Open Source
          - Developer Tooling
          - API Design
          - Speech-to-Text
          - Voice Agents
          - Community Building
        knowsLanguage:
          - English
        nationality: British
        alumniOf:
          - "@type": Organization
            name: The Open University
      - "@type": BlogPosting
        "@id": https://lukeocodes.dev/jev-system-one-model#article
        headline: "Jev: The ChatGPT Co-Creator's System One Model Can't Talk"
        alternativeHeadline: "Jev: The ChatGPT Co-Creator's System One Model Can't Talk"
        description: "TypeSafe AI's Jev is a System One model that decides instead of talking: 70-500ms, $0.042/MTok, output free. Diogo Almeida's RLHF led to ChatGPT."
        datePublished: 2026-09-17T00:00:00.000Z
        dateModified: 2026-09-17T00:00:00.000Z
        url: https://lukeocodes.dev/jev-system-one-model
        mainEntityOfPage: https://lukeocodes.dev/jev-system-one-model
        inLanguage: en
        author:
          - "@id": https://lukeocodes.dev/authors/luke#person
        isPartOf:
          "@id": https://lukeocodes.dev/#website
        keywords: AI, Industry, Opinion, jev, typesafe ai, diogo almeida, rlcd, system one models, model release
        articleSection: AI
        about:
          - "@type": Person
            name: Diogo Almeida
          - "@type": Organization
            name: TypeSafe AI
          - "@type": Product
            name: Jev
        abstract: "Diogo Almeida, who co-invented RLHF and InstructGPT at OpenAI, spent two years building Jev: a System One model that cannot generate text, only typed decisions with calibrated confidence. TypeSafe AI prices input at $0.042/MTok, output free, running 70-500ms. Automation needs a model it can trust, not one that talks."
        speakable:
          "@type": SpeakableSpecification
          cssSelector:
            - .post-tldr
            - h1
        image: https://lukeocodes.dev/og.png?h=Jev%3A+The+ChatGPT+Co-Creator%27s+System+One+Model+Can%27t+Talk&d=TypeSafe+AI%27s+Jev+is+a+System+One+model+that+decides+instead+of+talking%3A+70-500ms%2C+%240.042%2FMTok%2C+output+free.+Diogo+Almeida%27s+RLHF+led+to+ChatGPT.&e=Writing
        wordCount: 984
        timeRequired: PT5M
        publisher:
          "@id": https://ably.com/#organization
      - "@type": BreadcrumbList
        itemListElement:
          - "@type": ListItem
            position: 1
            name: Home
            item: https://lukeocodes.dev
          - "@type": ListItem
            position: 2
            name: Writing
            item: https://lukeocodes.dev/blog
          - "@type": ListItem
            position: 3
            name: "Jev: The ChatGPT Co-Creator's System One Model Can't Talk"
            item: https://lukeocodes.dev/jev-system-one-model
      - "@type": FAQPage
        "@id": https://lukeocodes.dev/jev-system-one-model#faq
        mainEntity:
          - "@type": Question
            name: What is Jev?
            acceptedAnswer:
              "@type": Answer
              text: "Jev is TypeSafe AI's first System One model, released in early access on 15 September 2026. It is not a language model: it cannot generate text, only typed decisions with calibrated confidence, a Choice, a Score, or a yes/no probability. Input is priced at $0.042 per million tokens and output is free."
          - "@type": Question
            name: Who is Diogo Almeida?
            acceptedAnswer:
              "@type": Answer
              text: Diogo Almeida is the founder and CEO of TypeSafe AI and an ex-OpenAI researcher. At OpenAI he co-invented RLHF and InstructGPT, the methods that became the research behind ChatGPT and GPT-4. He spent two years in stealth building Jev before releasing it in September 2026.
          - "@type": Question
            name: What is RLCD?
            acceptedAnswer:
              "@type": Answer
              text: RLCD stands for Reinforcement Learning for Calibrated Decisions, TypeSafe AI's training algorithm for System One models. Where RLHF optimises for human preference, RLCD trains for calibrated confidence on narrow decision surfaces, so software can act on an answer without a human checking it.
          - "@type": Question
            name: Can Jev hallucinate?
            acceptedAnswer:
              "@type": Answer
              text: Not in the way LLMs do. Jev's output shape is fixed by construction, so it never emits a malformed or off-schema answer. It can still return a schema-valid answer that is factually wrong, and every answer ships with a confidence value so calling software knows when to escalate.
          - "@type": Question
            name: Does Jev replace GPT or Claude?
            acceptedAnswer:
              "@type": Answer
              text: "No. Jev has no chat interface, a 32K context window, no image input, and generates neither text nor code. It is positioned to run alongside an LLM: the language model defines the decision logic, and Jev executes the repeated structured part of it cheaply and fast."
---

[Luke Oliff.](/)

- [Blog](/blog)
- [CV](/cv)
- [Uses](/uses)
- [User manual](/user-manual)
- [Living with ADHD](/living-and-working-with-adhd)
- [RSS](/rss.xml)

[Luke Oliff · Writing](/blog)

# Jev: The ChatGPT Co-Creator's System One Model Can't Talk

Sep 2026 · [AI](/blog/category/ai) · 5 min read · [Luke Oliff](/authors/luke)

**TL;DR:** Diogo Almeida, who co-invented RLHF and InstructGPT at OpenAI, spent two years building Jev: a System One model that cannot generate text, only typed decisions with calibrated confidence. TypeSafe AI prices input at $0.042/MTok, output free, running 70-500ms. Automation needs a model it can trust, not one that talks.

Diogo Almeida's new model cannot talk. Jev, released in early access on 15 September by TypeSafe AI, returns typed decisions with calibrated confidence: a choice from up to 255 options, a score, or a yes/no probability. It is not a language model, and the man who helped build ChatGPT says that is the point. Jev runs 70 to 500 milliseconds end to end, prices input at $0.042 per million tokens, and charges nothing for output.

## The two-year answer

Almeida is the OpenAI researcher behind RLHF and InstructGPT, the methods that became the research behind ChatGPT and GPT-4. What he kept asking after co-inventing it: why have superhuman chat models not led to AGI? Chat is solved. Automation is not.

Two years in stealth, $40 million in backing, and a team from OpenAI, Google Brain, Meta and FAIR went into his answer. Jev. The argument underneath it is that chat was the wrong target. A model built to talk is a different thing from a model built to decide.

## Jev doesn't chat, it decides

Jev has no chat interface. It cannot generate strings at all.

Give it structured state and it returns one of three primitives: a Choice, a Score, or a Noul, each with a confidence value between 0 and 1. Your software acts on the answer. The docs are blunt about the edges: 32K context window, no image input, no code, no prose.

The confidence value is the whole design. Calibrated confidence means the number Jev reports matches how often it is right: when it says 0.9, it is right about nine times out of ten. That is not a promise LLM APIs have kept in a form software can act on. Most say 0.9 and mean "sounds plausible".

The "can't hallucinate" coverage needs a qualifier. Jev structurally cannot emit a malformed answer, the output shape is guaranteed by construction. It can still return a schema-valid answer that is factually wrong, and Almeida said as much during the launch discussion.

## The demos make it real

Two demos tell you more than the benchmark numbers. There's a video of Jev playing Doom at about ten calls a second, roughly $7 an hour of play. There's a Wikipedia game where Jev races from page to page choosing among thousands of links. Both make the same point visible: this thing decides fast enough to sit inside a game loop, and cheap enough that nobody notices the bill.

## RLCD is the interesting part

The training method is RLCD: Reinforcement Learning for Calibrated Decisions. Almeida's critique of RLHF is specific. It trained for human preference, which made models superhuman at following instructions, and it also produced overconfidence and mode dropping, the exact failure modes that keep a human in the loop. RLCD trains for the opposite property. A machine can act without asking permission.

This matters because trust is the thing that is broken. An API that says 0.9 and is right 60% of the time is not usable in a pipeline, no matter how good the prose is. TypeSafe is betting the market for a decision you can trust is bigger than the market for a sentence you cannot.

## What the numbers actually say

The headline ranges are 20-200x faster and 40-400x cheaper. They are self-reported, which is worth remembering while the model is waitlist-only. The benchmark video on their proof page compares workflows, not single calls. One example: a System One task that ran in 0.114 seconds at $0.000081 took 8.566 seconds and $0.013880 on a frontier model. Across the workflow suite, the average is 193.6x faster and 444.6x cheaper against GPT-6 Astra and Fable 5.1.

The free output is not a promotion stunt, which I assumed at first. There is no autoregressive generation to meter: the architecture returns all outputs at once, in parallel. The comparison models take 3 to 329 seconds per call largely because they generate one token at a time. Jev's latency is the direct result of skipping that loop.

## Where this bites for voice agents

If you build agents, this is the interesting part. Most pipelines use one large chat model as thinker and talker: it classifies the intent, extracts the arguments, routes the work, drafts the response. You pay reasoning cost at every step, even when the step is a decision that fits on one line.

In voice pipelines, where I spend my days, the pattern is everywhere. Intent classification, escalation routing, fraud triage. Each is currently a full LLM call with JSON output and a parser you trust about as far as you can throw it.

Jev changes the shape of that. Set a confidence threshold at 0.85 and escalate anything below it. That is the escalation pattern production voice agents spend months hand-building, and it stops being a design constraint when decisions cost near nothing. The cleanest framing I've seen this week splits the stack: language models for communication, coding models for implementation, decision models for high-volume judgment. Jev is the first decision layer built for that job from the ground up.

## What's left to prove

None of this tells you whether the decisions are any good. Speed and price you can verify in a day. Decision quality takes months of production traffic, and TypeSafe is still a waitlist.

The structural claim survives the scepticism though. I have watched whole teams design around the cost of a single LLM choice, caching aggressively and batching calls to cut round trips. A 70ms decision model at near-zero marginal cost is built to remove exactly that behaviour.

Almeida has the track record, and early access means the claims get tested before anyone has to commit. If you build automation, the experiment is cheap: put a decision where you used to put an LLM call, and read the confidence score. Jev takes milliseconds, prices input at $0.042 per million tokens, and the waitlist is open.

[← Newer: Why I Left Speechify](/why-i-left-speechify)

[All posts](/blog) →

## Search this site

`GET https://lukeocodes.dev/search.json?q=<words>` returns matching posts as JSON, each with its page URL and its markdown URL. Add `&limit=<1-50>` for more than 10. How it works: [/blog/search](https://lukeocodes.dev/blog/search.md).

```sh
curl "https://lukeocodes.dev/search.json?q=developer+relations"
```

---

© 2026 Luke Oliff. Posts live at the root of this site.

- [GitHub](https://github.com/lukeocodes)
- [LinkedIn](https://www.linkedin.com/in/lukeocodes)
- [X](https://x.com/lukeocodes)
- [Bluesky](https://bsky.app/profile/lukeocodes.dev)
- [Email](mailto:luke@lukeoliff.com)
- [RSS](/rss.xml)

## Cookies

This site sets one analytics cookie, from Google Analytics, and only in a browser that accepts the cookie banner. A client that does not run scripts sets no cookies, so there is nothing to accept or decline here.

[Cookie policy](/cookies)
