---
title: "It Doesn't Talk — It Just Decides: Jev, the Decision-Only AI, and How to Run the Free Local Version on Your PC"
date: 2026-10-07
model: admin
category: reviews
summary: What Jev (TypeSafe) is — a decision-only AI that returns structured judgments instead of words. There's no free tier so you can't run real Jev on your PC for free, but here's how to run Kev, an open model to the same spec, locally with a single Ollama command.
tags: Jev,TypeSafe,decision-model,Kev,local-ai,Ollama,free-ai
---

# It Doesn't Talk — It Just Decides: Jev, the Decision-Only AI, and How to Run the Free Local Version on Your PC

**The short version: Jev isn't a chatbot, it's a "decision component."** It doesn't generate language. It returns probabilistic judgments your program can use directly. And there is no way to run real Jev on your PC for free, because there's no free tier at all. What you can do is run Kev — an open model built to the same spec — on your own machine for free and get the same work done. This post separates the two.

## 1. What is Jev — an AI that only decides

Jev is a model TypeSafe, a startup, released on September 15, 2026. Its founder, Diogo Almeida, is known as a former OpenAI researcher and co-inventor of RLHF and InstructGPT, and the company raised a $40 million seed round. The training is unusual too — instead of optimizing for pretty prose, they trained it with a method called RLCD to produce **well-calibrated judgments**. The company calls it a "System One model."

If models like ChatGPT or Claude are optimized for generating long text, Jev is the opposite. **It doesn't generate text.** You send it a state (a document or JSON) plus a question, and it hands back an answer inside a predefined shape. The whole API is just three question types.

**Choice — pick one.** Chooses one option out of up to 255. Returns the chosen option along with the probability and confidence for each candidate.

**Score — assign a grade.** Gives an ordered grade from 2 to 10, and can also output values in between. With three levels, for instance, the range is 0 to 2, and it can return something like 1.4 — "slightly above the middle."

**Noul — a yes/no probability.** A variant name for "boolean." Returns a number between 0 and 1 as the probability of "yes." Something near 0.5 means "not sure." Note that Noul has no separate confidence field.

Feed it a customer complaint and, instead of writing a long sympathetic reply, it returns a judgment like the above in a single call, processed in parallel and back within hundreds of milliseconds. The company says end-to-end latency is 70–500ms, priced at $0.042 per million input tokens with output free. Where general large models sometimes break their structured-output format (the company claims 0.58–45.5% of the time), Jev is structurally incapable of breaking the shape, so format errors are ruled out at the source.

That said, it doesn't guarantee the "right answer within the shape." It will hold the shape and can still be wrong in content — a limitation the company itself acknowledges.

## 2. Using real Jev — the steps and the cost

First, a reality check: **real Jev is not something anyone can just start using right now.** API keys are issued from a waitlist, so you have to wait your turn. There's no free tier and no trial credit. "Using Jev free on your PC" simply doesn't apply. Worth being clear about that up front.

That said, if you know the steps, you can start the day your key arrives.

**Step 1: Get a key.** Sign up for the waitlist at console.typesafe.ai and get your key. Routing through a gateway is also possible.

**Step 2: Install the SDK.** `pip install typesafe-sdk` on Python 3.10+, or `npm install @typesafe-ai/sdk` on Node 20+.

**Step 3: Call it.** The SDK reads the `TYPESAFE_API_KEY` environment variable, and the default model is `jev-latest`. Per judgment it runs about $0.0004 based on the documented example, which makes it well priced for bulk classification work.

```python
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

jev = TypeSafeClient()  # reads TYPESAFE_API_KEY
r = jev.system_one(
    state={"text": "Refund me. I paid yesterday and got charged twice."},
    questions={
        "is_refund": Noul(instructions="Is this a refund request?"),
        "dept": Choice(
            instructions="Pick the owning department",
            criteria={"billing": "Billing and subscription issues", "technical": "Bugs and integration issues"},
        ),
    },
)
```

Worth noting that OpenAI has also announced a Decisions API preview in the same category, so "decision-only models" are turning from one company's niche into a field of their own.

## 3. Free on your PC — running Kev locally

This is the core of today's post. **Kev** is a family of Jev-compatible decision models made by Jared Palmer. It's Apache 2.0 licensed so you can use and modify it freely, and it speaks the same `/v1/systemone` spec as Jev. Sizes are 0.8B, 4B, and 8B, and since it's built on Qwen3.5 it takes multilingual input too.

Here's the order I followed myself. The three easiest paths:

**Method 1: one Ollama command (easiest).** GGUF conversions are on Hugging Face, so if you have Ollama installed this is all it takes:

```bash
ollama run hf.co/ggml-org/Kev-4B-GGUF:Q4_K_M
```

At 4B it runs on an ordinary PC. One catch: Kev is **decision-only**, so if you chat with it like a chatbot you'll get nothing back. It's meant to be asked questions through the `/v1/systemone` spec.

**Method 2: serve with uv.** The official method from the GitHub repo. Needs Python 3.12+ and uv.

```bash
uv run --extra serve python -m kev.serve --run jaredpalmer/kev-4b --port 8008
```

The first run downloads the adapter and base model. Since it's the same spec, when a real Jev key eventually comes through you can swap the client code almost as-is.

**Method 3: browser, no install.** There's a web demo on Hugging Face if installing things is a hassle, and you can get a feel for it there first. For a hosted free playground there's also decisions-api.dev.

## 4. Six practical tips

**First, use it as a component, not a chatbot.** Jev and Kev don't talk. The real-world setup is "a generative model drafts, and the decision model handles classification, review, and gating." Asking a Noul once more before an agent does something risky — a payment, a deletion — is the classic guardrail use case.

**Second, calibrate your probability thresholds on your own data.** Being calibrated is the company's claim; there are no independent validation studies. Criteria like "auto-approve above 0.7" need to be tested on your own data. Money-moving actions and read-only lookups can't share a threshold.

**Third, know Noul and Score's traps.** Noul has no confidence field. The probability itself is the expression of uncertainty. Score returns values between grades, so you need to define your boundaries in advance.

**Fourth, running locally makes privacy free.** With Kev on your PC, sensitive documents never leave your machine and you still get classification and scoring. The only cost is electricity.

**Fifth, verify Korean yourself.** Kev's base is multilingual so Korean input is accepted, but the published evaluations are English-based. Korean thresholds should be checked by hand.

**Sixth, don't misread "no hallucination."** It means it won't return values outside the schema, not that it can't be wrong. There should always be a "human approval" step behind a decision model.

## Wrapping up

AI is moving from an era of talking well into one of deciding well, and Jev sits right in the middle of that shift. Even if real Jev is paid and behind a waitlist for now, Kev lets you practice the same work on your PC for free. Why not touch a decision-only model for the first time this evening with a single Ollama command?

* Related video reference: [The Hottest AI Right Now, Zeb: How to Use It for Free on Your PC](https://www.youtube.com/watch?v=NW5r0QojYEs)