How to Use Jev: API Key, First Request and Where to Get It

Jev is TypeSafe AI's decision model: you send it data and typed questions, and it returns a choice, a score or a probability rather than text. If you already know what it is and want to know how to use Jev in your own code, this is the practical guide. If you don't, start with our explainer on what Jev is.

Everything below comes from TypeSafe's own documentation, checked in October 2026.

Where to get Jev

There are four routes, and the right one depends on what you're already using.

Route	Best for	Model identifier
TypeSafe directly	Full access, the playground, newest versions	jev-latest or jev-1.13.0
OpenRouter	Trying it alongside other models on one bill	typesafe/jev-1.13
Cloudflare Workers AI	Apps already running on Workers	typesafe/jev
Vercel AI Gateway, Netlify, LangChain	Fitting it into an existing stack	Via each integration

Going direct gives you the playground and the current model aliases. The gateways are easier if you already route models through one and would rather not add another vendor relationship and another key.

One timing note: when Jev opened to everyone in late September 2026, demand forced TypeSafe to pause new signups briefly. That has passed, and the company's homepage now states there is no waitlist.

How to use Jev: the five-minute version

1. Try the playground first

Sign in at console.typesafe.ai, paste any text as the state, and add a question. TypeSafe's quickstart uses a support message as the example:

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

Add a Noul question, "Does this message express urgency?", and you'll get a number back. Ten minutes in the playground will teach you more about how to phrase questions than any amount of reading.

2. Create an API key

Keys live in the dashboard at console.typesafe.ai. Store it the way you'd store any secret: in an environment variable, never in your repository, and never in front-end code, since anyone can read what the browser downloads.

3. Make one request

The whole API is a single endpoint:

POST https://api.typesafe.ai/v1/systemone
Authorization: Bearer <API_KEY>
Content-Type: application/json

A request has three parts: the state you want judged, the model, and a map of named questions.

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "I have been trying to connect my Stripe account for 3 days and it keeps failing.",
    "model": "jev-latest",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "The message conveys urgency or time-sensitivity"
      }
    }
  }'

4. Read the response

{
  "model": "jev-1.13.0",
  "answers": {
    "is_urgent": { "type": "noul", "noul": 1.0 }
  },
  "usage": { "input_tokens": 392, "output_tokens": 65 }
}

The keys in answers are the names you chose, so your code can read answers.is_urgent.noul without any parsing.

5. Use an SDK once you're past the first call

For Python, which needs 3.10 or later:

pip install typesafe-sdk

For JavaScript, install @typesafe-ai/sdk. The Python client reads TYPESAFE_API_KEY from the environment and defaults to jev-latest, so there's nothing else to wire up.

The three question types, and when to use each

Noul asks whether a statement is true and returns a probability from 0 to 1. Use it for yes/no gates: does this contain a refund request, is this spam, does this passage answer the question.

Choice picks one option from a set you define, and returns a probability for each plus a confidence value. Use it for routing: which team, which category, which handler.

"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"
  }
}

Score rates the state against ordered levels you describe, and returns a score, probabilities and confidence. Use it for anything with a rubric: severity, quality, frustration, risk.

"frustration": {
  "type": "score",
  "instructions": "How frustrated the customer appears",
  "criteria": [
    "Calm, just stating facts",
    "Frustrated but civil",
    "Very angry, strong language"
  ]
}

Write the criteria as descriptions, not labels. "Frustrated but civil" tells the model where the boundary sits; "medium" does not.

Ask everything at once

This is the single biggest practical tip, and it's where the economics come from.

All three types can go in one request. Every question is evaluated in parallel and in isolation against the same state, so adding questions barely changes the response time, and each one avoids the context-rot you get from stuffing everything into one prompt.

TypeSafe's own cookbook on batching reports that putting 13 questions into a single call was 12.2 times cheaper and 10 times faster than asking them separately, with no change to the answers.

The pattern worth copying from their docs is speculative fan-out: ask the questions you might need, not just the ones you know you need, because the marginal cost is near zero and your code can ignore the rest.

Act on confidence, not just the answer

Choice and Score return a confidence value alongside the probabilities. Noul does not; it returns only its probability.

Confidence describes how settled the distribution is, which is different from how likely the top answer is. The routing pattern that falls out of it:

1. High confidence: act automatically.
2. Middle: queue for human review.
3. Low: escalate to a person, or hand the case to a reasoning model.

Pick the thresholds by running a few hundred real examples and looking at where the model's mistakes actually sit, rather than guessing at 0.8 because it looks like a round number.

Costs and limits worth knowing before you build

• Price: $0.042 per million input tokens. Output tokens are free.
• Rate limits: 100,000 tokens per second and 80 requests per second, and TypeSafe notes these are being adjusted dynamically because of demand, so don't hard-code assumptions.
• Context: 64k tokens per request, with 32k for the state plus the longest question. Cloudflare's listing shows a 32,000-token window.
• Input types: text only, as a string, JSON object or array of text. No images, audio or video.
• Versions: jev-latest and jev-preview both currently point to jev-1.13.0. Pin the exact version in production so a model update doesn't silently change your thresholds.

That last point is the one teams get wrong. If your business logic depends on a 0.8 threshold, a new model version can shift the distribution underneath you. Pin the version, and re-tune deliberately when you upgrade.

A realistic first project with Jev

Don't start by replacing anything. Start by measuring.

1. Pick one LLM call in your app that produces a label, such as categorising inbound messages.
2. Run both for a week. Keep the existing call as the decision, and log what Jev would have said alongside it.
3. Compare on your own data: agreement rate, cost, latency, and crucially where they disagree.
4. Switch only the band you trust, routing low-confidence cases to the old path.

That gives you a number for your workload rather than a vendor's benchmark, and it's the same method worth applying to any model swap.

When not to use it

If you need a written reply, a summary, generated code or an explanation, this is the wrong tool and no amount of clever question design will change that. Use ChatGPT, Claude or another assistant for that work, and see our AI chatbots ranking.

A common architecture uses both: Jev decides whether a request needs the expensive model, and only the cases that pass go through. That is where the cost savings in most real deployments come from, not from replacing the big model entirely.

FAQ

How do I get a Jev API key?

Sign in at console.typesafe.ai and create a key in the dashboard. There is no waitlist as of October 2026, after signups were briefly paused when the model launched.

What is the Jev API endpoint?

A single endpoint, POST https://api.typesafe.ai/v1/systemone, with an Authorization: Bearer header. The request body contains state, model and a map of named questions.

Is there a Jev SDK?

Yes, for Python (pip install typesafe-sdk, requires Python 3.10 or later) and JavaScript (@typesafe-ai/sdk). The Python client reads TYPESAFE_API_KEY from the environment and defaults to jev-latest.

Can I use Jev without a TypeSafe account?

Yes, through a gateway. It's listed on OpenRouter as typesafe/jev-1.13 and on Cloudflare Workers AI as typesafe/jev, and it's available through Vercel AI Gateway, Netlify and LangChain integrations.

How many questions can I ask in one request?

Several, and you should. Questions run in parallel against the same state, so batching barely affects latency. TypeSafe's own cookbook found 13 questions in one call ran 12.2 times cheaper and 10 times faster than separate calls.

How much does Jev cost to run?

$0.042 per million input tokens, with output free. Because you pay only for what you send, keeping the state tight is the main lever on your bill.