On this page

How to use TypeSafe AI

TypeSafe AI sells Jev, a model that doesn't write text. You send it some data and a set of typed questions, and it returns choices, levels or yes-no probabilities that your code can act on. It's cheap and fast, but not a substitute for a chat model, and it can still be wrong.

The short version

  1. Get a key from the TypeSafe console, run pip install typesafe-sdk, and call client.system_one() with a state and some questions.
  2. Questions come in three everyday types: Choice picks an option, Score finds a level, and Noul returns a yes probability from 0 to 1.
  3. Act on the probability, not on confidence. TypeSafe suggests 0.7 and 0.3 as starting Noul thresholds, with a separate path for the band between them.
  4. Keep math, counting and date comparison in your code. TypeSafe's own docs say Jev is unreliable at them.
Could a knowledgeable person answer it in a second?"Does this message convey urgency?", as opposed to "Analyze this and decide what to do"
YesAsk JevUse one narrow question, and handle the logic in your code
NoBreak it up, or use an LLMSplit it into small questions. Writing and long reasoning aren't what Jev does.
TypeSafe's test for a good question, from its Primitives docs. Answers come back as data, so your code stays in charge of what happens next.
TypeSafe's example of an expense claims policy with four numbered sentences on the left, an arrow reading becomes, and a flow diagram on the right where the model answers questions about one expense claim and the code then decides the outcome.
How TypeSafe thinks about this. A written policy becomes separate model questions plus plain code rules, so only real judgments go to the model. Screenshot captured from the public page. Tap the image to see all of it. Image: TypeSafe workflow evals, retrieved November 2026. The current app may look different.

At a glance

What it is
A typed decision model, not a chatbot
Model
jev-1.14.0, also jev-latest
Price
$0.042 per million input tokens, with free output
Speed
About 100 ms for most calls, says TypeSafe
Context
64k per request, 32k per question
Input
Text and JSON. Images are preview only.

Is TypeSafe AI right for me?

Good fit if

  • You need classification, routing or scoring inside software, at high volume
  • You want typed answers without writing parsers for model output
  • You want a real-time check, such as a guardrail, in a user-facing request path
  • You're comfortable tuning thresholds and testing on your own data

Look elsewhere if

  • You need generated text, code or summaries, because Jev doesn't produce any
  • You need arithmetic, dates or counts, which TypeSafe says to keep in code
  • You work mainly in languages other than English and can't test them first
  • You need the highest accuracy on hard decisions, where its own chart shows larger models ahead

How do I make my first Jev call?

A request has two main parts: the state, which is what to judge, and questions, which is what you want to know about it. All questions run at once.

From TypeSafe's quickstart. Needs Python 3.10 or later.

# python3 -m venv .venv && .venv/bin/pip install typesafe-sdk
# export TYPESAFE_API_KEY="your-api-key"
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

ticket = "Our API integration started returning 500 errors on every request about 20 minutes ago, and we can't process any customer orders until this is fixed."

with TypeSafeClient(model="jev-latest") as client:
    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.choices["department"].choice)
print(response.scores["frustration"].score)
print(response.nouls["is_urgent"].noul)

The same idea over HTTP. Node needs 20 or later, with @typesafe-ai/sdk.

curl https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "I was charged twice for my subscription this month.",
    "questions": {
      "billing": { "type": "noul", "instructions": "Is this message about billing?" }
    }
  }'
# The docs' sample response: "answers": {"billing": {"type": "noul", "noul": 0.98}}

Worth knowing from the start

  • Question IDs are for your code and aren't sent to the model
  • So put the full question in instructions
  • Option names and descriptions are both sent
  • Use an object as state when you have several fields

What couldn't be checked

  • The console blocked automated readers on 5 November 2026
  • So sign-up steps and any free credit weren't verified
  • TypeSafe's launch post said early access, and its site now says Create Account
  • Check for a waitlist or starting credit when you sign up
Watch: Asking JEV's Creator the Hard Questions About This Hot New AI ModelIndependent tutorial by The TWIML AI Podcast with Sam Charrington, not made by the vendor. Screens may differ from the current version.

This interview comes from an independent podcast. TypeSafe's own demo videos are on Vimeo and embedded on its blog.

Should I use Choice, Score or Noul?

Pick the one your code can act on directly. A Choice maps to code paths, a Score to a threshold, and a Noul to an if.

The question types
TypeUse it whenYou get backExample
ChoiceOne of a known set, with no orderchoice, probabilities, confidenceWhich team handles this?
ScoreA position on a scale you can describescore, legend, probabilities, confidenceHow severe is this bug?
NoulA clean yes or nonoul, from 0 to 1Did they ask for a refund?
BoxWhere something is in an image. Preview only.box, confidenceWhere is the logo?
Source: TypeSafe, Primitives, read 5 November 2026. TypeSafe's launch post says Choice supports up to 255 options.

A Choice always picks something. Even if nothing fits, you'll get an answer. TypeSafe advises against adding an "other" option, which it says competes with your real ones for probability. Add a companion Noul instead, which asks whether any option fits, and act on the Choice only if that says yes.

Companion Noul pattern. Illustrative, based on TypeSafe's docs.

questions = {
    "meeting_type": Choice(
        instructions="What type of meeting is this?",
        criteria={"standup": "...", "planning": "...", "retrospective": "..."},
    ),
    # The companion: act on meeting_type only if this is high
    "any_type_fits": Noul(
        instructions="Is this meeting a standup, a planning session or a retrospective?",
    ),
}

A Noul of 0.5 isn't a medium. TypeSafe warns that for "Is this candidate strong in Python?", 0.5 means yes and no are equally likely, not medium skill. To measure skill, use a Score with defined levels. For a decision, ask a checkable question, such as whether the resume states they've used Python at work.

Decompose big judgments. Don't ask "rate this startup pitch". Ask about market size, technical feasibility and differentiation separately, then weight the answers in code. When your priorities shift, you change a number, and your prompts stay stable.

Which number should I act on?

Usually the probability, not confidence. TypeSafe says confidence measures how concentrated an answer is, not the chance that it's correct.

Where to put your threshold, per TypeSafe
TypeThreshold onWhy
NoulThe noul value. Try above 0.7 as yes, and below 0.3 as no.It's already the probability. Give the middle its own outcome.
Choiceprobabilities[choice]It's the chance that the option is correct
Score, one level mattersThat level's probabilityA position between levels can hide a split answer
Score, is it settled at all?confidence first, then route on the scoreIt catches answers spread across distant levels
Just need the best optionNothing. Take choice.No threshold needed
Source: TypeSafe, Confidence and Agent skill, read 5 November 2026. Thresholds are starting points, so test on your own data.
The same confidence means different things
Number of optionsTop probabilityconfidence
20.750.5
30.670.5
100.550.5
Source: TypeSafe, Confidence, read 5 November 2026. For a fixed number of options, confidence is a transformation of the top probability, so checking both adds no extra evidence.

Risk-scaled thresholds, adapted from TypeSafe's example to use the probability

action = response.answers["action"]
p = action.probabilities[action.choice]

if p < 0.5:
    route_to_human(message)        # the model really is unsure
elif action.choice == "check_balance":
    show_balance(account_id)       # low stakes, easy to undo
elif action.choice == "approve_transfer" and p > 0.9:
    confirm_then_execute(account_id)  # high stakes, still confirm
else:
    ask_user_to_confirm(account_id)

Keep questions and thresholds in one file. TypeSafe's agent-skill page says those are the most important things to review, and that agents "aren't great at writing questions". Treat them like the business rules they are.

How cheap and fast is Jev really?

The price is simple: $0.042 per million input tokens, with free output. TypeSafe's bigger comparison numbers come with caveats that it states itself.

Prices and limits
ItemValue
Input$0.042 per million tokens, or $42 per billion
OutputFree
Normal context64k per request, and 32k per question
Long context262k with TypeSafe-Danger-Zone-Long-Context: true. Same token price, but slower and less accurate.
Number of questionsNo separate limit, as long as the request fits
Rate limitsSet per organization, in tokens and requests per second. Over limit returns 429.
Response time70 to 500 ms in the launch post, and about 100 ms for most calls in the docs
Source: TypeSafe, Models, blog and How to build, read 5 November 2026. TypeSafe says it can't prove pricing isn't subsidized, and that its published evals were run from the US West Coast, where its service is based.

Rough cost. A 1,000-token request is about $0.000042, so a million such requests is about $42. That's this guide's arithmetic. Questions count toward input, and TypeSafe's sample shows input_tokens and output_tokens in usage.

TypeSafe scatter chart titled Average of 4 workflows, accuracy versus cost, with a log cost axis from $0.0001 to $1. Jev sits furthest left at about 68 percent accuracy. Sol and Opus 5 are near 74 and 73 percent at much higher cost. Prompt versions of models are generally lower than workflow versions, and Haiku 4.5 prompt falls below the chart.
TypeSafe's chart. Read it two ways: Jev costs far less, and larger models at higher cost are more accurate. Diamonds are the same workflow, circles are one big prompt. Image: TypeSafe blog, retrieved November 2026. The current app may look different.
TypeSafe's published workflow results, averaged over four workflows
ModelAccuracyCost per caseTime per case
Jev67.8%$0.00040.4 s
GPT-5.6 Luna66.8%$0.003312.9 s
GPT-5.6 Terra67.9%$0.030410.1 s
Claude Sonnet 567.8%$0.117478.1 s
GPT-5.6 Sol74.1%$0.083623.3 s
Claude Opus 573.1%$0.176137.8 s
Source: evals.typesafe.ai, read 5 November 2026. Accuracy means agreement with reference labels from GPT-6 Astra and Claude Fable 5.1 at high thinking, not ground truth.

TypeSafe's own caveats on these numbers

  • The "193.6x faster, 444.6x cheaper" figures are, it says, "on the higher end of real world gains"
  • Its own model team built the workflows, "so some bias could exist"
  • Using OpenAI and Anthropic models as reference favors those models, it notes
  • For LLMs, it used its own wrapper, which it says tends to be slower and costlier
  • Its latest "intelligence" chart is, in its words, "likely biased towards our models"
TypeSafe bar chart titled Structured Output Error Rate, with Jev-1.0 at 0.00 percent, GPT-5.6 Luna 0.49, Terra 0.58, Sol 1.93, Claude Sonnet 5 at 12.6, Opus 5 at 3.76, Fable 5.1 at 7.99, Gemini 3.8 Flash at 2.38 and Gemini 3.1 Pro at 1.92 percent.
A frame from TypeSafe's homepage animation. The 0% is a schema guarantee, and TypeSafe says "Our number is not empirical". The others come from OpenRouter data, with different mixes of requests. It says nothing about whether answers are right. Image: TypeSafe homepage, retrieved November 2026. The current app may look different.

Can Jev really not hallucinate?

It can't return an option you didn't define. It can still pick the wrong one. TypeSafe's phrase "zero hallucinations" is about the shape of an answer, not whether it's true.

Where Jev struggles, according to TypeSafe
FailureWhat goes wrongWhat to do instead
Literal readingIt answers the words you wrote, not what you meantPut boundary cases in the criteria
Math and counting"Jev is not a calculator", and counts are unreliableDo it in code. Ask one question per item, then add up.
Dates and timesIt reads dates as text, so ordering is unreliableExtract parts as Choices, and compare in code
IndirectionDouble negatives and multiple hops cost accuracyName the relevant field directly
Large stateUnrelated detail acts as a distractorFilter in code first, or use a Noul for relevance
Adversarial content"State is data, and Jev does not treat it as hostile by default"Be explicit in criteria, and test edge cases
Contradictory criteriaFor example, a Noul where true maps to noKeep instructions and criteria aligned
Choice orderOption order can change the answerReorder options, and check that the answer holds
GenerationIt doesn't generate textUse a generative model
Source: TypeSafe, Model jaggedness, read 5 November 2026. The page covers Jev 1.13, and the changelog lists 1.14 as mainly better multilingual support plus new preview features.

TypeSafe's pattern for counting: ask per item, and add up in code

from typesafe_sdk import Noul, TypeSafeClient

client = TypeSafeClient(model="jev-latest")
YES = 0.5  # your own threshold
items = ["typesafe", "apple", "california", "banana", "likes", "calibration", "orange", "vertex"]

result = client.system_one(
    {"items": items},
    {f"item_{i}": Noul(instructions=f"Is `items[{i}]` the name of a fruit?") for i in range(len(items))},
)
count = sum(result.nouls[f"item_{i}"].noul > YES for i in range(len(items)))

Treat outside text as hostile yourself. Jev is pitched for guardrails and verification, yet TypeSafe says content written to steer it "can move the answer". Rule of thumb, not a TypeSafe instruction: don't let a single Jev answer on untrusted text trigger a payment, a deletion or an account change.

Language. English is the primary training language and has the best accuracy, says TypeSafe. Others, including CJK scripts, are "handled but not equally well", so test before relying on them. Jev 1.14's main listed improvement is better multilingual support.

Will updates change my results?

They can if you use an alias. jev-latest moves when a new release ships, so pin a version once you've tuned thresholds against it.

Model names
NamePoints toUse it for
jev-latestjev-1.14.0Prototypes, and the SDK default
jev-previewjev-1.14.0, for nowTrying builds ahead of latest
jev-1.14.0FixedProduction, with tuned thresholds
jev-1.13.0FixedExisting tuned systems
Source: TypeSafe, Models, read 5 November 2026. Every response names the versioned model, so log it. TypeSafe says it intends 60 days' notice before deprecating 1.13, and 30 days for 1.14, with a policy to come.
TypeSafe console Organization settings with a sidebar of Profile, Organization, Members, Shares and Billing, an organization name field, Public links turned on, and under Model improvement a Help improve TypeSafe models switch turned on, with text saying it permits TypeSafe to read and analyze the organization's inputs and outputs to understand model jaggedness, applying to everyone.
A setting worth checking: Help improve TypeSafe models lets TypeSafe read your inputs and outputs to find failures, and applies to your whole organization. TypeSafe calls it an opt-in, and says it still won't train on your queries. This is its sample account, and it's cropped. Image: TypeSafe blog, retrieved November 2026. The current app may look different.

TypeSafe's data statements

  • "Jev is not trained on customer requests or responses"
  • Jev isn't fine-tuned per customer, and all accounts use the same weights
  • SOC 2 Type II report, by request through its Trust Center
  • Zero data retention for enterprise customers

Preview features, on your own risk

  • Images need TypeSafe-Danger-Zone-Images: true
  • Box needs Jev 1.14 and the same header
  • TypeSafe says these aren't "up to our standards" for production
  • The models page still lists input as text, which is about the stable path
TypeSafe bar chart titled Overall intelligence, watermarked TypeSafe AI and antibench.com, with a warning banner reading Warning: AI benchmarks, please don't trust them. Jev 1.14.0 scores 60.0, Jev 1.13.0 58.9, then kev-27b 46.7, pplx-decider 46.0, clef 44.3, clef-flash 38.8, kev-4b 36.9 and d1-3b 33.8.
TypeSafe's internal measure, which carries its own warning banner and a vendor watermark. It compares only open-weight models, and TypeSafe tells you to focus on your own tests. Image: TypeSafe blog, retrieved November 2026. The current app may look different.
Watch: Jev by TypeSafe AI | What is a System-1 Decision Model | CampusXIndependent tutorial by CampusX, not made by the vendor. Screens may differ from the current version.

Can my coding agent build with Jev?

Yes. TypeSafe publishes a skill that gives Claude Code and other agents its API details and patterns. Use it for the plumbing, and review the questions yourself.

From TypeSafe's docs. Pick one method.

# Claude Code
claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

# Other agents
npx skills add typesafe-ai/skills --skill typesafe-ai

Common problems

  • Agent isn't using it? Name it, or run /typesafe:typesafe-ai.
  • Agent invents fields? Update the skill, because a stale one can cause that.
  • Thresholds everywhere? Often you can just take the top option.
  • Routing looks wrong? Check your thresholds, then make questions more specific.

Patterns to look up

  • Companion Noul, when a list may not fit
  • Composite scoring, for weighted judgments
  • Confidence routing and probability routing
  • Fan-out, for many questions in one request

A good first use, from TypeSafe. Ask your agent to find "complex parsing or other fragile code" that a judgment could replace, then look at the plan before implementing. If you have an existing LLM app, its cookbook has guardrails and double-checking citations recipes, which add Jev alongside your current model.

Hidden tips

Details that are easy to miss, each with the official page that backs it up.

  • Reorder your options as a test

    TypeSafe has seen option order affect some Choice answers. Run the same input with options reversed. If the answer flips, your options need clearer descriptions.

    Model jaggedness
  • Use names, not hex codes

    Jev does better on semantic forms than raw numbers. Convert hex colors or RGB to a name or bucket in code, and ask the model only the judgment part.

    Model jaggedness
  • Don't interpolate a Score

    TypeSafe warns against computing an exact magnitude between two levels. Use the expectation to check a threshold, but don't reconstruct a number from it.

    Model jaggedness
  • Point at fields by path

    Name a state field in backticks, such as order.charges, when a question concerns one part of it. That removes a hop, which TypeSafe says costs accuracy.

    Primitives
  • List your models from the API

    GET /v1/models returns aliases with release dates. Versioned IDs such as jev-1.14.0 work even when they aren't in the list.

    Models
  • SDKs already retry 429s

    TypeSafe's client libraries retry rate-limited calls and honor retry-after. Only direct HTTP callers need to write that themselves.

    Models
  • Add questions without side effects

    Each question is evaluated independently, so one answer isn't hidden context for another. You can add or remove questions without changing the others' results, says TypeSafe.

    Primitives
  • Long context isn't free of cost

    It's the same token price, but TypeSafe says it's slower and less accurate. Send the header only on requests that need it, and filter your state first when you can.

    Models

TypeSafe AI FAQ

What is TypeSafe AI?

A company building System One Models, which make typed decisions for software, rather than writing text. Jev is its first public model, launched on 15 September 2026.

How much does Jev cost?

TypeSafe lists $0.042 per million input tokens, with free output. It says it can't prove the price isn't subsidized, but expects pricing to go down rather than up. Enterprise and higher-limit plans are by contact.

What is a Noul?

TypeSafe's yes-or-no question type. The answer is one number from 0 to 1, which is the probability of yes. There's no separate confidence field.

Is Jev better than GPT or Claude?

For different jobs. TypeSafe's own evals show Jev at similar accuracy to some mid-tier models at far lower cost and time, and behind the largest models on accuracy. It can't write text. Test it on your own data.

Does Jev train on my data?

TypeSafe says Jev isn't trained on customer requests or responses. A separate organization setting lets it read inputs and outputs to find failures. Zero data retention is available for enterprise customers.

Can Jev read images?

Only in preview. Send the TypeSafe-Danger-Zone-Images header. TypeSafe says images and Box questions aren't yet ready for production, and that all models perform worse on images than on text.

Can Jev be tricked by prompt injection?

It can be influenced. TypeSafe says content written to steer the model can move the answer, and that Jev doesn't treat state as hostile by default. Test your integration and don't rely on one answer for risky actions.

Sources

Facts checked 5 November 2026. Products change, so confirm anything important on the official pages.