AI with Unnati

AI Educator & Content Creator · CEO & Co-Founder, Maester Labs

TypeSafe AI · Jev

Jev: the AI that decides instead of talking

Jev is TypeSafe AI's first "System One" model. It never writes a paragraph. You send it text and a few questions, and it returns typed answers with confidence scores in about 70 to 500 milliseconds.

Why it's fast

Normal AI models write an answer one word at a time. Jev gives up writing entirely. It reads your text, answers all your questions at once, and returns fixed-format results: a choice, a score, or a yes/no probability. That single trade is why TypeSafe claims 70 to 500 ms per call and $0.042 per million input tokens, with output free. It is not a smarter chatbot. It is a fast decision-maker for software.

Where to get Jev

You can't download it

Jev is a proprietary model that runs on TypeSafe's servers. You use it through a website (the Playground) or an API. There are no open weights to run on your own machine. Access is early access with a waitlist, and TypeSafe says it is letting developers in over time.

Careful with lookalikes

A community project called openjev exists on GitHub. Its own README says it copies the interface pattern using a small open model. It is not Jev and it is not made by TypeSafe.

How to use it

Pick the route that fits you. All of them hit the same model.

A. No code: the Playground

  1. Open the Playground and log in.
  2. Paste any text as the state, for example a customer complaint.
  3. Add a question, like "Does this message express urgency?" as a Noul.
  4. Add more questions. Mix all three types and see every result at once.

B. Python SDK

  1. Install it (needs Python 3.10 or newer): pip install typesafe-sdk
  2. Set TYPESAFE_API_KEY in your environment.
  3. Send a state plus questions. The SDK defaults to jev-latest.
  4. JavaScript or TypeScript instead: npm install @typesafe-ai/sdk (Node 20+).
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient()   # reads TYPESAFE_API_KEY

ticket = "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."

response = client.system_one(
    state=ticket,
    questions={
        "department": Choice(
            instructions="Which team should handle this",
            criteria={
                "billing": "Payment or subscription issues",
                "technical": "Bugs or integration problems",
                "sales": "Pricing or account questions",
            },
        ),
        "frustration": Score(
            instructions="How frustrated the customer appears",
            criteria=[
                "Calm, just stating facts",
                "Frustrated but civil",
                "Very angry, strong language",
            ],
        ),
        "is_urgent": Noul(
            instructions="The message conveys urgency or time-sensitivity",
        ),
    },
)

print(response.answers["department"].choice)  # "technical"
print(response.answers["frustration"].score)  # 1.0
print(response.answers["is_urgent"].noul)     # 1.0

Example from TypeSafe's official quickstart.

What comes back

# department   technical   (technical 0.85, billing 0.15, sales 0.00, confidence 0.78)
# frustration  1.0         ("Frustrated but civil", confidence 1.0)
# is_urgent    1.0

C. Raw API (cURL)

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "I was charged twice. Please fix this ASAP.",
    "model": "jev-latest",
    "questions": {
      "urgency": {
        "type": "noul",
        "instructions": "Does this message express urgency?"
      }
    }
  }'

D. Build with Claude Code

claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

# other agents (Codex etc.)
npx skills add typesafe-ai/skills --skill typesafe-ai

Then tell your agent: "Use the TypeSafe skill to build a CLI that scores documents on several dimensions. Ask me what I want to score."

Pin your version

jev-latest currently points to jev-1.13.0 and will move when a new release ships, which can change answers. If you tune confidence thresholds, use the exact ID jev-1.13.0. Rate limits are also changing without notice while TypeSafe adds GPUs (250k tokens per second and 1,200 requests per minute at the time of writing).

The 3 question types

That's the whole API. Every question in one call is answered in parallel, so adding more questions barely slows it down.

Pick one

Choice

Choose one option from a list, up to 255 options. Returns the choice, a probability for each option, and a confidence score.

Rate it

Score

Rate the text on an ordered scale of 2 to 10 described levels. Returns a score (it can land between levels), probabilities, and confidence.

Yes or no

Noul

Is this statement true? Returns one number from 0 to 1: the probability that the answer is yes.

The trick that makes it work

Ask small, single-purpose questions, then combine the answers in your own code. Instead of "rate this startup pitch", ask separately about market size, feasibility and differentiation, then weigh them with your own formula.

Best use cases

Jev fits when the same decision repeats a lot and the possible answers are known in advance. Think of it as a smart if statement for judgments a normal if can't make.

Route and triage

  • Support tickets, emails, intent detection
  • Model routing: cheap model for easy prompts, Claude or GPT for hard ones
  • Insurance claims, financial-crime alerts, legal intake

Docs pattern: act automatically when confident, send to a human when not.

Guardrails and verification

  • Catch jailbreaks and prompt injection before they reach your LLM
  • Check whether a citation really supports a claim
  • Screen every LLM input, output and tool call cheaply

TypeSafe cookbooks: LLM guardrails, citation check, RAG passage filtering.

Tag huge datasets

  • Label millions of reviews, papers, listings or comments
  • Screen papers for a systematic review
  • Extract features to feed a normal ML model

Launch-week demo, self-reported: 1,018 research papers classified for $0.08, versus $3.99 to summarise them with a text model.

Real-time loops

  • Game bots and in-app decisions that must feel instant
  • Browser and computer-use agents that pick the next click
  • Advisory decisions in robotics, with code keeping safety

Community build, self-reported: a browser agent searched real flights in 7.1 seconds for $0.0039.

Search, rank and RAG

  • Rerank search results and score relevance
  • Filter retrieved passages before an expensive model sees them
  • Semantic search over the lines of a long document

TypeSafe's reranking cookbook lifted top-10 accuracy from 38% to 62% on a legal test set.

Screening and scoring

  • Resumes and applications against explicit job criteria
  • Lead scoring against an ideal customer profile
  • Content moderation and ad-policy checks
  • Semantic code lint checks in CI

Keep a human in the loop for anything high-stakes. Use confidence to decide when.

5 beginner projects to build with it

  • Support-ticket routerChoice for the team, Score for frustration, Noul for urgency.
  • Internship / job screenerScore each application on 3 to 4 skills, then combine with your own weights.
  • Comment and DM sorterTag incoming messages by intent and flag spam or urgent ones.
  • Research-paper triageNoul "is this an RCT?" over a batch of abstracts.
  • LLM guardrail wrapperCheck every user message for jailbreaks before it hits Claude or GPT.

Jev vs Claude, GPT, Gemini

The honest answer

Jev isn't "better". It's different. It can't write, code, explain or chat. It does one job, bounded decisions, much faster and cheaper. For everything else you still want a normal LLM, and the smart setup uses both.

 JevClaude / GPT / Gemini
What it outputsTyped answers, probabilities and confidenceGenerated text (chat, code, anything)
How it answersAll questions in one parallel passOne token at a time
Speed per call70 to 500 ms (TypeSafe's figure)Seconds to minutes for frontier models
Input price$0.042 per million tokens, output freeRoughly $0.20 to $10 per million, output costs more
Invalid or off-list outputCan't happen. Answers stay inside your optionsPossible
Can it be wrong?Yes. It can pick the wrong valid optionYes
Confidence scoreBuilt in, trained to be calibratedUsually has to be prompted, tends to be overconfident
Writing, coding, chatNoYes
Explains its answerNo, numbers onlyYes
Open-ended reasoningWeak. Built for quick judgmentsStrong
Input typesText onlyText plus images and more, depending on the model

TypeSafe's own benchmark

Four workflows: security incidents, agent traces, invoices, customer service. "Agreement" means how closely a model matches the average answer of two top frontier models. It is not ground truth.

ModelAgreementCost per caseLatency
Jev67.8%$0.00040.4s
GPT-5.6 Terra67.9%$0.030410.1s
GPT-5.6 Sol74.1%$0.083623.3s
Claude Opus 573.1%$0.176137.8s

How to read this fairly

Jev roughly ties a mid-tier model and sits about 5 to 6 points below the top two. The workflows were built by TypeSafe's own team and no independent reproduction has been published yet, so treat the numbers as vendor-reported. TypeSafe says the reference answers come from OpenAI and Anthropic models, which likely understates Jev. Its published numbers include GPT, Claude and DeepSeek. They do not include Gemini, so there is no Gemini comparison to quote.

On "100x faster, 100x cheaper"

TypeSafe's own range is about 40x to 200x faster. Its headline is up to roughly 194x faster and 445x cheaper on its best workflow, which it says is on the high end of real-world gains. The pricing may also be subsidised, which TypeSafe itself says it can't yet disprove.

Reach for Jev when

  • The same decision runs thousands or millions of times
  • The answer is one of a known list
  • It has to feel instant, under a second
  • You want a confidence number to decide when to escalate

Reach for Claude / GPT / Gemini when

  • You need writing, code or a summary
  • You need the reasoning explained (audits, regulated work)
  • The task is a one-off or open-ended
  • The input includes images, audio or video

Best pattern, from TypeSafe's own docs: let Jev classify and route at high volume, let plain code handle what it can, and hand only the hard minority to a big LLM.

Where it breaks

TypeSafe publishes its own list of weak spots for jev-1.13. Read this before you ship anything.

"Can't hallucinate" is narrower than it sounds

Jev can never return something outside your options or the wrong data type. It can still pick the wrong valid option. TypeSafe says its 0% error figure is guaranteed by design, not measured.

It reads very literally

It answers the question you wrote, not the one you meant. If you catch yourself explaining what you "really meant", that explanation belongs in the instructions.

Not a calculator, and dates are just text

Counting, arithmetic and date comparisons are unreliable. Extract the parts with Jev, then do the math in code.

Too much irrelevant text hurts accuracy

Send only what the question needs. Limits are 64k tokens per request, and 32k for the state plus your longest question. Filter first.

It can be steered by hostile text

Text written to argue for its own classification can move the answer. If users control the input, test edge cases before launch.

English works best, text only, and no writing

Other languages are handled but not equally well, so test on your own content. No image, audio or video input. No text generation at all.

It's early days

Launch-week demos are self-reported and are not production case studies. Rate limits and the model behind jev-latest can change. Evaluate on your own data first.

Try it free

Open the Jev Playground

Paste any text, add a Choice, a Score and a Noul question, and watch the confidence numbers come back.

Open the Playground

Get access

Join the early access waitlist

Jev is hosted by TypeSafe AI and gated behind a waitlist. Join on the official site.

Go to TypeSafe AI

Build with it

Read the official docs

Quickstart, API reference, SDKs and worked cookbooks for routing, guardrails, search and more.

Open the Docs

Follow along

More free AI guides

I share new AI tools, guides and breakdowns like this one on Instagram.

@aiwithunnati

Sources

Compiled 21 Sep 2026 from public sources. Speed, price and benchmark figures are TypeSafe's own unless stated. Details may change quickly, so check the official docs before building.