Your software needs a decision, not an essay. A ticket lands, and the code must choose: billing, bug or abuse? Most stacks ask a large language model, then pay for every word it writes to explain itself. This guide covers how to set up Jev, the decision model built for the job, in about ten minutes.
Jev is the first System One model from TypeSafe AI, released on September 15, 2026. It skips token-by-token generation, so answers arrive almost instantly. You send a state and a typed question, and it returns a typed answer with probabilities attached. That single design choice explains most of what follows.
The setup is short because the surface is small. Both official SDKs are covered here: the Jev JavaScript SDK for Node.js, and the official Python client. We also read a first answer together, then close with the mistakes new teams make in week one. Ten minutes of setup covers both, and the replay habit matters more than either.
In this guide
- The 30-second answer
- What you’ll learn
- Before you start: the docs quickstart and one narrow task
- How to set up Jev with the JavaScript SDK
- How to set up Jev with the Python client
- Reading your first answer
- Bulk jobs with the Jev Bulk Classifier
- Pinning, test seams and staging safety
- Common first-week mistakes
- Frequently asked questions
- The bottom line
The 30-second answer
Here is the short version. Jev is a decision model, not a chat model. Its input is text, a JSON object, or an array of texts describing the current state.
Its questions are typed, with every option defined in advance. So it picks from your menu instead of composing prose. If nothing fits, it says so with a typed empty answer instead of improvising.
When builders describe the Jev System One model, they mean three practical things. The package, the typed question, and the first answer. The package installs in one line, the question is a list you already know, and the answer reads itself. Each takes minutes, because the model refuses to do the slow part, which is writing.
Setup is short because the model refuses to write; it only decides.
Key takeaways
- Install the Jev JavaScript SDK with npm install @typesafe-ai/sdk on Node.js 20 or later.
- The Jev Python client ships with typed questions, model pinning and test seams.
- Answers arrive as Choice, Score or Noul, each with probabilities attached.
- The docs quickstart covers accounts and keys, so this guide can stay on code.
- Run your first test on one task, with about 50 recorded responses.
What you’ll learn
The route through this guide
- What to prepare before you install anything
- How to set up Jev with the JavaScript SDK and make a first call
- How to set up Jev with the Python client, including model pinning
- Reading a Choice answer, from probabilities to confidence
- Where bulk jobs fit once the first call works
- The mistakes that trip up new teams in week one
Before you start: the docs quickstart and one narrow task
Two steps make the first run smooth. First, open TypeSafe AI’s documentation, because it has a quickstart section and use-case guides that cover accounts and access. The use-case guides then show what other teams shipped, from routers to guards. Those steps change often, while the code below rarely does, so the docs own them.
Second, pick one narrow task before writing any code. The getting-started advice from semly.ai is blunt: keep the first test to a single task. For example, gather 50 recorded AI responses from one industry and one workflow.
That set becomes your replay suite, and it turns setup into a measurable experiment. Freeze the set once you have it, so later runs stay comparable.
What to have ready
| Item | Why it matters |
|---|---|
| One narrow task | Replay results only mean something when the question stays fixed |
| 50 recorded responses | Your replay set comes from one workflow, in one industry |
| A written question | The option list is your policy, so write it down first |
| Node.js 20 or Python | The documented runtimes for the two official SDKs |
| The docs quickstart open | Accounts and access live there, not in this walkthrough |
New to agents altogether? Our AI agents for beginners guide covers the vocabulary first. Everyone else can move straight to the install.
How to set up Jev with the JavaScript SDK
The Jev JavaScript SDK serves JavaScript and TypeScript teams, on Node.js 20 and later. Install it from npm with npm install @typesafe-ai/sdk, then import the client where your decisions live. The steps here stay narrative on purpose, while the official Jev quickstart shows the exact lines.
The client’s signature trick is type inference. A call to client.systemOne() infers return types from your question definitions. So a Choice question comes back as a typed object, with autocomplete nobody maintains by hand.
If how to set up Jev went fine but the call failed, check the boring things. The runtime is older than Node.js 20, or the option list drifts from the docs. Sometimes the question sneaks in a second task. So write the question down first, and keep the first call embarrassingly small.
Define the question before you call. Keep the option set tight, and decide what the typed empty answer should mean in your flow. If the three answer shapes feel fuzzy, our guide to Choice, Score and Noul walks through them with examples.
Naming matters more than it looks. The question text should read like a policy line, while each option reads like a verdict a person could defend. When reviewers can guess the distribution before the call, the question is ready. When they cannot, the options are doing the judging, and that is backwards.
Your first Jev call, in four steps
The state deserves one more sentence. It can be richer than a single string, so send the ticket text plus account JSON when context matters. Because everything is described up front, the model judges the whole situation instead of one lonely line. Arrays also help when the decision depends on a conversation, not a single message.
How to set up Jev with the Python client
Python teams get the Jev Python client, the official typesafe-sdk package, and its interface mirrors the JavaScript flow. You define typed questions, send a state, and read typed answers back. Because the questions carry their own options, nothing arrives as prose that needs parsing.
The two official SDKs at a glance
| Dimension | JavaScript and TypeScript | Python |
|---|---|---|
| Install | npm install @typesafe-ai/sdk | The official typesafe-sdk package |
| Questions | Options defined per typed question | Options defined per typed question |
| Answers | Types inferred by client.systemOne() | Typed answers on a sync lifecycle |
| Extras | Apify bulk classifier with JavaScript examples | Model pinning, test seams, error handling |
Three features deserve attention before the first run. Model pinning locks the version you tested against, which matters while the platform is young. Test seams let you stub the client in CI, so your suite runs without touching the network.
The sync lifecycle and error handling follow normal Python patterns, so retries feel familiar. If your stack is .NET, community wrappers such as TypeSafeAI.Net exist, though the official clients should come first.
Which client should your team pick? The honest answer is the one your service already speaks. Both clients expose the same three answer types, so the choice is about your runtime, not the model. A TypeScript service should not grow a Python sidecar for one decision. A Django shop should not bolt on Node either, for the same reason.
Reading your first answer
Once you know how to set up Jev, reading answers is the easy half. A Choice answer carries the selected option, a probability for every option you offered, and one confidence value. Read the distribution rather than only the winner. When one option holds most of the mass, the call is safe to automate.
Score answers return a number grade, which suits ranking and risk work. Because a Score is a number, it sorts records without any extra parsing. Noul is the typed empty answer, returned when nothing genuinely fits. Build the Noul path early, because every option set eventually meets an unmatched case.
Log every answer with its probabilities from day one. Those logs become your calibration evidence, and they make audits boring. A simple table with the state, the pick, and the spread is enough. Boring audits are the goal.
Rerunning is cheap, which is the privilege of a fast decision model. Use it liberally during week one.
Thresholds turn numbers into policy. In an illustrative setup, a team might auto-act above 0.9 confidence, review between 0.6 and 0.9, and escalate below that. The exact bands are yours to tune, because they depend on the cost of a wrong call.
Distributions also tell you when the question was wrong. When two options split the mass evenly, the state may genuinely sit on the boundary. That is not model failure; it is a design signal. Split the question, or add the missing option, then rerun the batch.
Bulk jobs with the Jev Bulk Classifier
Single calls prove the design, while batches pay the bills. Apify hosts a Jev Bulk Classifier API with JavaScript examples. So a folder of records becomes one job, with typed verdicts at the end. Nothing about bulk work changes how to set up Jev; the question stays identical across every item.
Bulk classification suits the same narrow questions you asked one at a time: sorting requests, scoring records, screening outputs. The published examples are short enough to skim before you build. Keep one question per queue, because probabilities from different option lists do not compare cleanly. If volume is the draw, the reported numbers explain why.
Scheduling stays ordinary too, which is the quiet payoff of how to set up Jev once and reuse it everywhere. A cron job pulls the backlog, and the batch call returns typed verdicts. Your code writes them back to the queue without a parser in sight. If a run fails halfway, replay it, because identical questions give comparable results.
Launch-week coverage put Jev at 40 to 200 times faster than frontier LLMs. On cost, the same coverage reported 40 to 400 times cheaper on decision tasks. TypeSafe AI’s own material claims similar intelligence on System One tasks at two orders of magnitude faster.
Treat every multiplier as early coverage rather than settled law. Independent trackers logged 220-plus documented Jev cases within weeks, so the pattern is not theoretical.
Pinning, test seams and staging safety
Model pinning is the boring feature that saves weekends. Pin the version you validated, because an unpinned dependency can shift under you. When you upgrade, do it on purpose, with a replay of your 50 recorded cases before the change ships.
Test seams matter just as much. Stub the client inside your test suite so decisions are simulated, and keep one integration test against the live service. That way the pipeline stays fast, while the real path still gets exercised.
Monitoring closes the loop. Watch the Noul rate, the confidence spread, and the disagreements with human reviewers. When any of those moves, you have drift, and drift found early is a ticket instead of an incident.
Staging gets one more rule: mirror the question definitions exactly. A drifted option list changes distributions silently, and nobody notices until a verdict looks wrong. Keep a frozen copy of the definitions in version control, and diff them on every deploy.
Want the full rollout plan? Our guide on how to migrate a workflow to Jev covers staging, rollback and cutover.
Common first-week mistakes
Most first-week trouble has little to do with how to set up Jev itself. It comes from question design and rushed rollouts. These six come up again and again in early community writeups. Read them once before the install, then again after the first replay.
- Skipping the docs quickstart, then inventing account steps the official guides already answer.
- Asking one wide question with 40 fuzzy options instead of three narrow ones.
- Automating on the first answer instead of reading the probability spread.
- Forgetting the Noul path, so unmatched cases crash instead of escalate.
- Skipping model pinning, then debugging a distribution that moved overnight.
- Testing on invented examples instead of 50 real recorded responses from one workflow.
None of these are exotic, and all of them are cheap to avoid. Fix the first two early, because they cause most of the rest. Also worth an hour: skim the wider tooling before you commit. Our roundup of Jev ecosystem tools covers the trackers, SDKs and wrappers worth knowing about.
Frequently asked questions
What do I need before I install anything?
An account with TypeSafe AI, plus a supported runtime. That means Node.js 20 or later for JavaScript, or Python for the official client. The docs quickstart walks through access and keys. Installing is the simple half of how to set up Jev.
What is the npm package for Jev?
The npm package is the typesafe-ai sdk, installed with npm install @typesafe-ai/sdk. After that, client.systemOne() infers return types from your question definitions. Node.js 20 or later is the documented requirement. Nothing else blocks the first call.
Does Jev work with Python?
Yes. The Jev Python client is the official typesafe-sdk package. It ships with typed questions, a sync lifecycle, model pinning, error handling and test seams. Community .NET wrappers also exist for other stacks. Pick the one that matches your service, and keep the question definitions in sync.
How do I test Jev without shipping mistakes?
Keep the first test to one task, with about 50 recorded responses from that workflow. Replay them through Jev and compare the picks with what your team would have done. Pin the model version before the run. Keep the replay set frozen so runs stay comparable.
Can Jev handle bulk classification jobs?
Yes. Apify hosts a Jev Bulk Classifier API with JavaScript examples for batch work. The same typed question you use one at a time runs across the whole dataset. Typed verdicts come back for the entire batch at once.
How fast is Jev compared with a language model?
Launch coverage reported similar intelligence on System One tasks at two orders of magnitude faster. DataCamp’s analysis put it at 40 to 200 times faster and 40 to 400 times cheaper than frontier LLMs. Both figures are early, moving numbers. Your own replay results are the ones that matter.
The bottom line
In short, how to set up Jev comes down to three moves. Install the Jev SDK for your stack, define one typed question with honest options, then replay real cases before automating. Because the model skips token generation, the whole loop fits inside an afternoon. After that, the model either earns a queue or it does not.
Keep the scope narrow, pin the version, and log every answer with its probabilities. If the distributions track your team’s judgment, add the next task. That is the whole adoption curve, one decision at a time.
One caution belongs here. Pricing is not public, so budget from the reported examples rather than a rate card. Re-check the docs before you commit, because the numbers are young. Your own replay results beat any launch post.
Sources
- TypeSafe AI, Jev documentation quickstart and use-case guides — typesafe.ai
- GitHub, the open-source LLM proposes, Jev answers harness and Jev project description — github.com
- Apify, Jev Bulk Classifier API with JavaScript examples — apify.com
- semly.ai, getting-started advice for a first, single-task Jev test — semly.ai
- explainx.ai, reference to TypeSafe AI’s quickstart section and use-case guides — explainx.ai
- Jev Radar, independent ecosystem tracker logging documented Jev cases — jevdirectory.org