Who the hell is Jev, and why is everyone talking about decisions?

Jev has been all over LinkedIn and X for two weeks. It is a decision model from TypeSafe AI, a startup founded by InstructGPT co-author Diogo Almeida, and it opened in early access on September 15. Jev is far more specialized than an LLM like Claude or GPT. You give it some text and a set of questions with fixed answers, like "Is this email spam?", and it returns an answer to each question with a probability attached. It will not draft an email for you.

It spread fast. Vercel reported that nearly 13% of paid teams on its AI Gateway used Jev within 24 hours, and a community list tracked 26 lookalike decision models by October 1, including one from Together AI at exactly Jev's price. OpenAI, which shut down its own classification endpoint in 2022, announced a Decisions API at DevDay on September 29 with no published price or docs. The New Stack wrote that OpenAI "probably rushed the announcement," and Almeida replied on X with "begun, the clone war has."

If this all seems new, well it is, but mostly to the folks posting about it. Classifiers aren't usually in the news the way Claude and GPT are. Nevertheless, they've spent decades doing background work like spam filtering, and building one used to be a big job.

Classifiers have run production decisions for decades

A classifier takes an input and assigns it to one of a fixed set of categories. Most also produce a probability, and the software around the model decides what to do with that number. Google's machine learning course calls the cutoff a classification threshold.

Spam filtering is the one everybody has used. Gmail's classifiers block more than 99.9% of spam, phishing and malware for more than 2.5 billion users. Visa's fraud model scores each transaction against more than 500 risk attributes in about a millisecond.

The model produces a score, and code turns the score into an action:

score = spam_model(email)  # probability this email is spam, 0.0 to 1.0

if score >= 0.95:
    move_to_spam(email)
elif score >= 0.70:
    add_label(email, "Review")
else:
    deliver(email)

Most of the design work happens in that middle band. Stripe Radar works the same way for payments. By default a risk score of 75 or above is blocked, and 65 to 74 goes to a manual review queue. Move the thresholds and you change how many cases a person has to look at and how many bad ones get through.

Building the model was the hard part. Paul Graham's 2002 essay A Plan for Spam describes six months of writing spam rules by hand before he switched to a statistical filter trained on mail he had already sorted. Stripe Radar has moved from logistic regression to gradient-boosted trees paired with a neural network, and then to a neural network on its own. Every one of those models needs labelled history, an ML team, and someone to retrain it when the data changes. Companies with an enormous number of decisions to make, like Google and Stripe, could justify that. Most companies couldn't.

How most people classify today

LLMs removed the training step. You describe the categories in a prompt and get a label back, with no labelled data at all.

In a qbash Task that is one model call with an output schema:

def email_text(email):
    return (
        f"From: {email.get('from')}\n"
        f"Subject: {email.get('subject')}\n\n"
        f"{email.get('body')}"
    )

verdict = qbash.ai.raw(
    email_text(email),
    model="gpt-6-luna",
    system="Decide whether this email is spam, phishing or a scam.",
    output_schema={
        "type": "object",
        "properties": {
            "is_spam": {"type": "boolean"},
            "confidence": {"type": "number"},
        },
        "required": ["is_spam", "confidence"],
    },
)
# {"is_spam": True, "confidence": 0.95}

This works, and is now the usual way to classify with an LLM. The confidence field is the weak spot. The model writes that number the same way it writes any other token, and studies of the confidence LLMs report find it runs high. Fine-tuned small classifiers also still beat zero-shot LLMs on text classification benchmarks. An LLM is the easiest classifier to set up, and usually not the most accurate one.

Jev goes through the same call. Change the model and replace the JSON Schema with Jev's question format:

SPAM_QUESTIONS = {
    "is_spam": {
        "type": "noul",
        "instructions": "Is this email spam, phishing or a scam?",
    },
    "category": {
        "type": "choice",
        "instructions": "What kind of email is this?",
        "criteria": {
            "personal": "From a person the recipient knows",
            "work": "About the recipient's job or a customer",
            "newsletter": "A publication the recipient subscribed to",
            "promotion": "Marketing or a sales offer",
        },
    },
}

emails = qbash.integrations.gmail.search_messages(
    query="in:inbox newer_than:1d", max_results=50, fetch_full=True,
)["messages"]

for email in emails:
    verdict = qbash.ai.raw(
        email_text(email),
        model="jev-latest",
        output_schema=SPAM_QUESTIONS,
    )
    score = verdict["is_spam"]["noul"]  # probability from 0 to 1

    label = None
    if score >= 0.95:
        label = "qbash/spam"
    elif score >= 0.70:
        label = "qbash/review"

    if label:
        qbash.integrations.gmail.add_labels(
            message_id=email["id"], add_label_ids=label,
        )

noul is Jev's yes-or-no question type, and its answer is a probability, so it drops straight into the thresholds from the spam filter above. Both questions are answered in one call.

A probability is not automatically a correct one. Independent testers have found Jev overconfident on some question types and dependent on the data it sees. Before you trust 0.95, run a few hundred emails you have already sorted and check how often 0.95 turns out to be right. Classifier teams have always run that check.

What it costs at a million emails a month

If you mostly pay for Claude or ChatGPT by the conversation, classification costs add up differently. Each call is a few hundred tokens in and a few tokens out, and it runs once per email. Here is a million emails a month at list price, assuming about 500 input tokens and 10 output tokens per email, with no caching or batch discounts:

Jev's cost is a range because it counts tokens differently. In independent tests it billed two to three and a half times as many input tokens as OpenAI's models for the same text.

If your classification runs on a frontier model today, this is where the savings are. AI/ML API ran the same tasks through six models and published what it was billed. Opus 5.5 cost between $1,621 and $8,243 per million decisions, 80 to 150 times what Jev cost. Thinking widens the gap. Opus 5.5 always thinks, and thinking tokens are billed as output, so a few hundred per email takes it from $2,200 to around $8,200 a month.

Against the cheapest LLMs, the price advantage mostly goes away. TypeSafe's headline of 444.6 times cheaper is a comparison with frontier models. In the same tests, with reasoning at its lowest setting, intent routing cost $98 per million decisions on Jev and $116 on GPT-6 Luna, and moderation cost $19 on Jev and $16 on Luna. At that end you are choosing on something other than price. Jev gives you a probability you can set a threshold on, and independent tests put it at roughly 2 to 12 times faster, which adds up when a Task makes several decisions in a row.

You also don't have to pick one model. A common pattern runs the cheap model on everything and sends only the uncertain cases to a larger one. A CMU preprint found a cascade of Jev then GPT-6 beat GPT-6 alone at 41% of the cost. Another study found that when Jev was confidently wrong, the LLM repeated the mistake about 96% of the time, so test a cascade on your own cases before you count on it.

The pattern outlasts the model

Jev is the first decision model a lot of people have heard of, and it probably won't be the only one they use. What carries over from one model to the next is the shape: a question with fixed answers and a probability, with code deciding what happens at each threshold. If one of your processes has a classification step in the middle, try a decision model there first.

Use Jev with qbash Tasks covers setup, and Jev Decision Prompts covers the question types.