Jev by TypeSafe: How It Works, How to Get Access, and 8 Real Use Cases

Most of the AI agents we see in production spend a surprising amount of their time doing something small. They read an email and decide if it matters. They read a ticket and pick a team. They look at a pull request and decide if it needs a human.

For the last two years, the default way to do that was to ask a large language model, wait a few seconds, parse whatever text came back, and hope it matched the format you asked for. It works, but it's slow, it costs more than it should, and every so often the model answers in a shape your code didn't expect.

Jev, the new model from TypeSafe AI, takes a different route. It doesn't write anything. You give it some text and a set of questions with fixed answers, and it hands back typed answers with probabilities attached. Your code reads those numbers and decides what to do.

We've been wiring Jev into real workflows on top of Swytchcode, starting with a Gmail inbox. This guide covers what Jev is, how it works, how to get access right now, and eight use cases where it actually earns its place. Where a use case ends in a real action (labelling an email, posting to Slack, issuing a refund), we show how that action runs too, because that's the part most Jev write-ups skip.

What is Jev?

Jev is a decision model. TypeSafe AI calls it a "System One" model, a nod to Daniel Kahneman's split between fast, intuitive thinking (System 1) and slow, deliberate thinking (System 2) in Thinking, Fast and Slow.

TypeSafe's founder, Diogo Almeida, put it this way in the launch post on September 15, 2026:

"Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out."

In plain terms: Jev is the thing you'd want sitting inside an if statement when the condition is fuzzy. "Is this email from a client asking for work?" "Which of these five teams should own this ticket?" "How urgent is this, on a scale of one to five?"

A few facts worth knowing up front:

• It doesn't generate text. There's no reply, summary or explanation. You get numbers and labels.
• It's in early access. TypeSafe is moving people off a waitlist, and it's also available through other gateways (more on that below).
• It's closed and hosted. No weights, no self-hosting. You call an API.
• The company is new but not small. The New Stack reported that TypeSafe came out of two years in stealth with $40 million in seed funding led by DCVC.

The name comes from the economist William Stanley Jevons. His paradox says that when something gets cheaper to use, people use far more of it. TypeSafe's bet is the same for intelligence: make each decision cheap enough and you'll find decisions to automate everywhere.

How Jev works

You send Jev two things:

1. State. The thing being judged. An email, a ticket, a JSON object, a log line.
2. Questions. A named map of questions, each with a type and the allowed answers.

Jev answers every question in parallel and returns one typed answer per question. There are three question types:

Here's the request from TypeSafe's quickstart, trimmed a little. It asks three questions about one support message:

{
  "state": "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. I'm losing sales. Please help ASAP.",
  "model": "jev-latest",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this",
      "criteria": {
        "billing": "Payment or subscription issues",
        "technical": "Bugs or integration problems",
        "sales": "Pricing or account questions"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "How frustrated the customer appears",
      "criteria": ["Calm, just stating facts", "Frustrated but civil", "Very angry, strong language"]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "The message conveys urgency or time-sensitivity"
    }
  }
}

And the answer that comes back:

{
  "model": "jev-1.13.0",
  "answers": {
    "department": { "choice": "technical", "confidence": 0.78,
                    "probabilities": { "technical": 0.85, "billing": 0.15, "sales": 0.0 } },
    "frustration": { "score": 1.0, "confidence": 1.0 },
    "is_urgent": { "noul": 1.0 }
  },
  "usage": { "input_tokens": 392, "output_tokens": 65 }
}

Nothing to parse, nothing to validate. answers.department.choice is always one of the three keys you gave it. That's what TypeSafe means when it says Jev "can't hallucinate": the shape of the answer is guaranteed. The answer itself can still be wrong, and TypeSafe says as much. Simon Willison made the same point in his notes on Jev: it's a black box, and "the only thing you're going to get back is a floating point number." You don't get a reason.

Why it's fast and cheap

Under the hood TypeSafe describes three new pieces: a new architecture, a parallel sampler, and a training method it calls Reinforcement Learning for Calibrated Decisions (RLCD). Chat models are trained to please humans or pass checks. RLCD trains Jev so that its probabilities are honest: when it says 0.9, it should be right about 90% of the time.

Because it isn't writing tokens one by one, all the answers come out in a single pass. TypeSafe reports 70 to 500 ms end to end, against 3 to 329 seconds for the frontier chat models it compared.

TypeSafe's own speed and cost comparison. These are vendor numbers from workflows TypeSafe wrote, so test on your own data. Source: typesafe.ai

The headline numbers on TypeSafe's site are 193.6x faster and 444.6x cheaper. The team itself says those are "likely on the high end of real-world gains," and that the reference answers came from averaging two other models. Treat them as a ceiling, not a promise.

What it costs

Pricing is simple: $0.042 per million input tokens, and output is free. For context, Willison noted that's slightly less than GPT-5 Nano. TypeSafe is upfront that it "can't prove it isn't subsidized," so expect the number to move.

A quick sense check using TypeSafe's own example: the support ticket above used 392 input tokens. At $0.042 per million, a million tickets like that would cost roughly $16.50 in Jev fees.

Why developers paid attention so fast

Jev launched on a Tuesday and was everywhere by Friday.

Vercel added it to its AI Gateway and published the numbers three days later: Jev reached more than twice as many paid teams in its first 24 hours as any earlier model launch, and nearly 13% of paid teams were using it by hour 24. Every other recent launch stayed under 7% after a full day.

Share of paid Vercel AI Gateway teams using each new model in its first day. Source: Vercel

Guillermo Rauch, Vercel's CEO, tested it as the safety reviewer for Vercel's fx tool, which checks every command before it runs. He wrote that Jev was "up to 18x faster (p95) and more accurate" than the model it replaced in that job. Rajiv Ayyangar at Product Hunt called it "incredibly impressive." Flavio Copes summed it up in one line that stuck: "Jev is a smart if statement."

Not everyone was sold. Developer Bartosz Mikulski ran Jev on 400 hand-drawn sketches turned into SVG coordinates and found it labelled more than half of them "airplane." He's the first to say the test was unfair, since Jev is built for text, not numbers. But it's a useful reminder: Jev has blind spots, and TypeSafe's own docs flag numbers, dates and adversarial text as weak areas.

How to get access to Jev

There are three practical routes today.

1. Directly from TypeSafe. Sign up at console.typesafe.ai, create an API key, and install the SDK:

pip install typesafe-sdk
export TYPESAFE_API_KEY=your_key_here

The endpoint is POST https://api.typesafe.ai/v1/systemone. There's also a JavaScript SDK. When we started our Gmail experiment in late September, new signups were reported to be paused while TypeSafe worked through the waitlist, so you may have to wait.

2. Through Vercel's AI Gateway. Vercel lists typesafe-ai/jev with no waitlist. You can point the TypeSafe client at the gateway, call an HTTP endpoint, or use the AI SDK's experimental_evaluate function. Usage is billed through Vercel. The changelog has examples for all three.

3. Through Swytchcode. Jev is now in the Swytchcode integration directory. You still need a key from TypeSafe, but you hand it to Swytchcode once instead of putting it in your code:

swy get jev
swy auth connect jev    # paste your Jev API key when asked

The advantage is that the decision and the action live in the same place. Your Jev call and your Gmail or Stripe call go through the same runtime, with the same policies, the same credential store and the same audit log. We'll show what that looks like in the use cases below.

The pattern: Jev decides, something else acts

Before the use cases, one idea that will save you a lot of grief.

Jev tells you what should happen. It doesn't do it. If Jev says "this email is a client request, urgent, reply today," something still has to call the Gmail API, add a label, maybe draft a reply. If Jev says "approve this refund," something has to call Stripe, make sure the refund isn't sent twice if the request retries, and stop if the amount is too big.

That second half is where most agent bugs actually live. We've written about it at length in why AI agents break in production and what an execution layer is. Short version:

state  ──>  Jev (typed decision + confidence)  ──>  your code (if / switch)
                                                         │
                         high confidence  ───────────────┼──> swytchcode exec <method>
                         medium confidence ──────────────┼──> human approval
                         low confidence  ────────────────┴──> do nothing / fall back

TypeSafe's confidence guide recommends exactly this three-band approach. It doesn't give fixed numbers. Its examples use 0.5 as the floor for sending something to a human and above 0.9 for high-stakes actions, and it tells you to scale the threshold to the cost of a wrong action. Labelling an email wrong costs nothing. Refunding the wrong customer costs real money.

On the Swytchcode side, every action runs through swytchcode exec, which checks your policies, injects the right credentials so the model never sees them, retries safely and records what happened. If you've never used it, swytchcode init sets up a project in about a minute:

swytchcode init asks which editor you use and whether to run in production or sandbox mode. Start in sandbox.

Now the use cases.

8 practical Jev use cases (with the action wired up)

Each one follows the same shape: the problem, the Jev questions, and the action that runs after.

1. Triage a Gmail inbox

The problem: An inbox mixes client requests, government notices, receipts and newsletters. You want the first two at the top and the rest out of the way.

This is the one we built first. Our test inbox belongs to a chartered accountant's practice, so the categories are client queries, compliance deadlines, billing, internal admin and newsletters. Jev gets four questions per email:

const questions = {
  is_actionable: {
    type: "noul",
    instructions: "Does this email require the recipient to personally do something: reply, review, sign, file, or decide?"
  },
  category: {
    type: "choice",
    instructions: "What is this email primarily about?",
    criteria: {
      client_query: "A client asking a question or requesting work",
      compliance_deadline: "A tax, GST or government notice, due date, or filing requirement",
      billing_payment: "An invoice, payment confirmation, or fee matter",
      internal_admin: "Staff, scheduling, software, vendors",
      newsletter_marketing: "Newsletters, promotions, marketing",
      other: "Anything else"
    }
  },
  urgency: {
    type: "score",
    instructions: "How time-sensitive is this email?",
    criteria: ["Not urgent", "Low", "Medium", "High", "Critical"]
  },
  suggested_action: {
    type: "choice",
    instructions: "What should happen to this email next?",
    criteria: {
      reply_today: "Needs a response within the day",
      schedule_followup: "Needs action, but can wait",
      delegate_to_team: "Can be handed to staff",
      file_for_records: "Keep for records, no action",
      ignore_or_delete: "Safe to ignore"
    }
  }
};

Both the Jev call and the Gmail calls run through Swytchcode. The Gmail side uses the Gmail integration: gmail.user.messages.get to list messages, gmail.user.messages.get1 to fetch one, and gmail.user.modify.create to apply labels like Jev/Urgent. We wrote up the full build, including code and the mistakes we made, in How to Build a Gmail Triage Agent With Jev.

2. File Google Drive uploads into the right folder

The problem: Shared drives turn into a dumping ground. Invoices, contracts and screenshots all land in "Uploads."

Use a choice question over your folder names, with the file name, type and the first page of text as state. Add an other option, because TypeSafe's docs recommend a "none of the above" choice whenever your list might not cover everything.

from typesafe_sdk import Choice, Noul, TypeSafeClient

client = TypeSafeClient()
answers = client.system_one(
    state=f"File: {name}\nType: {mime}\n\n{first_page_text[:3000]}",
    questions={
        "folder": Choice(
            instructions="Which folder does this file belong in?",
            criteria={
                "invoices": "Bills and invoices, sent or received",
                "contracts": "Signed agreements, NDAs, engagement letters",
                "kyc": "ID proofs, PAN, address proofs",
                "other": "Anything that does not clearly fit",
            },
        ),
        "has_personal_data": Noul(instructions="The file contains personal identity documents or ID numbers"),
    },
).answers

Only move the file when folder.confidence is high, and never move anything flagged has_personal_data without a person looking. Moving files is easy to undo; sharing a passport scan with the wrong folder is not. The Google Drive integration handles the move. Run swy discover "move a file to a folder in google drive" to find the exact method for your setup.

3. Decide which meeting invites to accept

The problem: Your calendar fills with invites you'd decline if you read them properly.

State: the invite title, organiser, attendee count, description and your existing events that day. Questions: a choice of accept / tentative / decline / ask_me, plus a noul for "this meeting needs me specifically, not just my team."

The actions come from the Google Calendar integration, using methods like calendar.event.get to read the invite. Keep decline behind an approval at first. A wrongly declined meeting with a client is the kind of mistake people remember. Our human-in-the-loop guide covers how to set that up without slowing everything down.

4. Route Slack messages to the right person

The problem: A busy #help channel where the right person sees the message an hour late.

Ask a choice question over your team's areas of ownership and a score for urgency. When the answer is clear, post a message in the right thread with slack.chat.postmessage.create through the Slack integration and tag the owner. This is a nice first project, because a wrong guess costs one extra message.

5. Triage GitHub issues and pull requests

The problem: New issues sit unlabelled, and small doc PRs wait as long as risky ones.

For issues: a choice for type (bug, feature, question, docs), a score for severity, and a noul for "this report includes steps to reproduce." For PRs: a score for risk based on the diff summary and touched files.

Then act through the GitHub integration. Our examples repo already uses methods like github.repo.issues.create and github.repo.comments.create.1, and the openclaw-swytchcode project is a full GitHub issue triage bot you can borrow from. If you're new to agents on GitHub, start with How to build a GitHub AI agent.

6. Approve or hold Stripe refunds

The problem: Support approves most refund requests by hand, even the obvious ones.

This is where confidence really matters. State: the customer's message, order age, past refunds and amount. Questions: a choice of approve / partial / deny / escalate and a noul for "the customer mentions a chargeback or legal action."

Jev's answer is only half the safety story. The other half is a rule that sits outside the model entirely. In Swytchcode, a policy can hold any refund over a set amount for a person to approve, no matter what Jev said:

{
  "id": "big-refunds",
  "target": ["stripe.refund.create3"],
  "when": { "field": "amount", "operator": ">", "value": 50000 },
  "action": { "type": "REQUIRES_APPROVAL", "message": "Refunds over 500.00 need approval" },
  "approval_timeout": "2h"
}

And because refunds are exactly the kind of call you never want sent twice, the Stripe integration runs with idempotency built in. If you want to see why that matters, read how Swytchcode prevents duplicate charges. Our refund agent demo is a working starting point.

7. Route support tickets in Intercom

The problem: Tickets land in one queue and someone spends the morning sorting them.

This is close to TypeSafe's own quickstart example: a choice for team, a score for frustration and a noul for urgency, all in one call. The Intercom integration assigns the conversation. One tip from TypeSafe's patterns page: ask the extra questions you might need in the same call ("mentions a refund", "mentions cancelling"). They're evaluated in parallel, so they add tokens but barely add time.

8. Score inbound leads in Salesforce

The problem: Sales follows up with every lead in the order they arrived.

Use score questions for company fit, buying intent and seniority of the contact, then combine them in code into one number. TypeSafe calls this "composite scoring." Write the result back to the lead record through the Salesforce integration, and use swy discover "update a lead in salesforce" to find the method. Our lead qualification example shows the CRM side with LangGraph.

Where Jev fits, and where it doesn't

Jev is very good at one kind of job. It's not a replacement for a chat model.

The two work well together. A common setup is Jev as a fast first pass that handles the clear cases, with an LLM (or a person) taking the uncertain ones.

There's also a fairness point. Willison wrote that he "really hope[s] nobody uses Jev to rank job applicants." A model that gives you a number and no reason is a poor fit for decisions about people. Keep it to emails, tickets, files and code.

And Jev isn't the only decision model any more. Fastino has released GLiDE and an open-weights model called GLiNER2.5-Decide, and several open reproductions of the idea have appeared. MarkTechPost's comparison is a good overview. If you need to run on your own hardware, those are worth a look.

Getting started

If you want to try Jev with a real app in the next half hour, this is the shortest path we know:

1. Get a Jev API key from TypeSafe.
2. Set up Swytchcode with npx swytchcode and swy init --mode=sandbox, or point your coding agent at our skills file and let it do the setup.
3. Connect Jev and one app: swy get jev, swy get gmail, then swy auth connect jev and swy auth connect gmail. Keys and tokens go into Swytchcode's credential store, not into a .env file.
4. Add only the methods you need. Only methods listed in tooling.json can run, which keeps a new agent on a short leash. The CLI quickstart walks through it.
5. Print Jev's answers first, before letting anything write back.
6. Add one policy for the action you'd least like to get wrong.

Want something to copy? The swytchcode-examples repo has ready-made agents for Gmail, GitHub, Stripe, Calendar and more, and the JavaScript and Python runtimes let you call exec straight from your code.

FAQ

What is Jev in simple terms?

Jev is an AI model from TypeSafe AI that makes decisions instead of writing text. You give it some text and questions with fixed answers, and it returns the answer it picked with a probability for each option.

Is Jev a large language model?

No. TypeSafe calls it a System One model. It's built on transformers, but it can't generate free text. It only returns choices, scores and yes/no probabilities.

How much does Jev cost?

TypeSafe charges $0.042 per million input tokens, and output tokens are free. TypeSafe has said it can't yet prove the price isn't subsidized, so expect changes.

How fast is Jev?

TypeSafe reports 70 to 500 milliseconds end to end. Independent developers have reported most calls finishing in around 100 milliseconds.

How do I get access to Jev?

Sign up at console.typesafe.ai (early access, with a waitlist) or use it through Vercel's AI Gateway as typesafe-ai/jev. To use your key with Swytchcode, run swy get jev and swy auth connect jev.

What are Choice, Score and Noul?

They're Jev's three question types. Choice picks one option from up to 255. Score rates something on an ordered scale. Noul gives the probability that a statement is true.

Can Jev hallucinate?

It can't return an answer outside the options you defined, so the format is guaranteed. It can still pick the wrong option, which is why you should set confidence thresholds and test on your own data.

Can Jev call APIs like Gmail or Stripe?

No. Jev only decides. You need your own code or an execution layer like Swytchcode to make the API call, handle credentials, retry safely and log the result.

Wrapping up

Jev is the first model we've used that feels like it belongs inside ordinary code rather than next to it. Ask a narrow question, get a number back, branch on it. It's fast and cheap enough that you can put it in places where an LLM call would never make sense.

But a decision is only useful once something acts on it, and acting is where things go wrong: wrong account, duplicate refund, a label applied to the wrong thread. That's the half we built Swytchcode for.

If you want to see both halves working together, start with the Jev integration and the Gmail triage walkthrough.