Learning how to use Jev takes one path: join TypeSafe AI's early-access waitlist, grab an API key from console.typesafe.ai, then send Jev a state plus questions — it answers with typed decisions and calibrated probabilities instead of generated text, and the fastest on-ramp is the official langchain-typesafe integration.
📺 Watch: LIVE: Jev AI - What You Need To Know!
🔥 Get the Agent OS as a free bonus: AI Profit Boardroom members get the full Agent OS zip, prompt libraries, daily tutorials and weekly live coaching calls. → Get inside
That last part changes how you work with it. Jev is not a chatbot. You never prompt it for paragraphs, because it cannot produce them. You hand it a situation, ask specific questions about that situation, and read structured answers off a typed response object. The judgment of an LLM, minus the essay.
This guide covers access, the state-plus-questions request model, the three question types, the LangChain wiring, and the two patterns — routing and tool risk screening — that make Jev genuinely useful inside an agent stack. Want the background first? Read what Jev actually is, then come back.
Get Access First: Waitlist, Console, Pricing
Jev is in early access, so nothing happens until TypeSafe lets you in. According to TypeSafe AI's official launch post from 15 September 2026, early access opened that day, with developers brought off the waitlist as fast as TypeSafe can manage. Step one is unglamorous: sign up at typesafe.ai and wait for the invite.
Once you are in, the console at console.typesafe.ai is where you create your API key. Keep it safe — you will export it as an environment variable in a minute.
Pricing, per the same launch post, is where Jev gets interesting: input costs $0.042 per million tokens and output is free. That works because Jev's outputs are tiny structured values, not streams of text. TypeSafe also quotes 70–500ms end-to-end responses — fast enough to sit inside a live request path instead of behind a queue.
How To Use Jev: Send a State, Ask Questions
Everything about Jev comes down to one request shape, and LangChain's integration guide spells it out: you send a state plus questions about that state.
The state is the situation you want judged. It can be raw text, structured data, or a list of LangChain messages — a support ticket, an incoming user request, a proposed tool call, a lead record. The questions are the specific decisions you need made about that state: which category does this belong to, how urgent is it, is this claim true.
You define the questions up front, build a classifier around them, and invoke it with your state. Per the guide, Jev processes all of your questions in parallel in a single call, and answers come back as typed fields you read straight off the response object — a chosen option here, a probability there, a confidence score alongside. No parsing JSON out of a chat reply. No pleading with a model to respond in a valid format.
That inversion — schema first, judgment second — is the whole mental model. Inside AI Profit Boardroom, where 3,000+ members build agent systems every week, this is the discipline we push constantly: force the model to commit to a typed decision, then build on the decision. Jev simply makes that the only mode it has.
📺 Watch: New FREE Hermes Computer Use Agents!
The Three Question Types
LangChain's guide documents three question types, and every Jev workflow is some combination of them.
| Question type | What you ask Jev | What comes back |
|---|---|---|
| Choice | Pick from predefined options — route this to billing, support, or sales | A probability for every option, plus an overall confidence score |
| Score | Rate the state against ordered levels, like low, medium, high | A continuous score plus a distribution across the levels |
| Noul | A yes-or-no question about the state | The probability the statement is true |
Noul is TypeSafe's own term for the yes/no type, so expect it in the docs. Notice the pattern: every answer arrives with its uncertainty attached. A Choice does not just say billing — it tells you how strongly it prefers billing over the alternatives. That is the raw material for thresholds: act automatically above a confidence bar you set, escalate to a human below it. For what the model is actually doing underneath, the Jev model deep-dive covers it.
Wiring Jev Into LangChain
The practical setup, straight from LangChain's integration guide, is two moves: install the langchain-typesafe package with your usual package manager, then set the TYPESAFE_API_KEY environment variable to the key you created in the console.
From there you build a classifier. In plain English: you declare your questions — the choices, the score levels, the yes/no statements — as a schema, then invoke the classifier with your state. The guide's examples pass in plain text, structured records, or existing LangChain message lists, which means Jev drops into a LangChain agent without reshaping your pipeline.
The response object hands back one typed result per question: the winning option and its probability for each Choice, the numeric score and its distribution for each Score, the truth probability for each Noul. A few lines of glue, zero prompt engineering, and every field is a real value your code can branch on.
Stuck on what your first schema should even be? That is exactly what a free strategy session is for — bring the decision you want automated and we will map it together.
📺 Watch: How to Use Hermes + NotebookLM for FREE!
The Two Patterns Worth Stealing: Routing and Risk Screening
LangChain's guide documents two production patterns that justify Jev on their own.
Model routing. Jev assesses the complexity of each incoming request so your stack can pick the right model — cheap and fast for simple asks, big and capable for hard ones. One Choice question in front of your agent, and you stop paying frontier-model prices to answer basic policy questions.
Tool risk screening. The pattern the guide calls AutoModeMiddleware puts Jev between your agent and its tools: every proposed tool call gets examined for risky actions before it executes. A Noul question — is this action destructive or irreversible — plus a confidence threshold decides whether the call runs automatically or waits for human approval.
That second pattern is the one I care about, because it is the critic seat in a builder-critic loop. If you have read the gauntlet loop piece, you know the architecture: builders generate, blind critics judge, benchmarks decide. A decisions-only model returning calibrated probabilities in under half a second is a natural fit for that seat. To be clear, I have not run Jev through the gauntlet yet — it is early access, and my verdicts land on Goldie Bench when I do — but the shape is right.
The economics back it up. On straightforward classification tasks, the guide cites up to 200x faster inference and 400x lower cost versus a general LLM call. Those are LangChain's numbers, not mine — but even at a tenth of that, every boring classification call in your stack becomes a Jev candidate.
Your First Jev Project: The Sensible Sequence
Access is still rolling out, so treat this as the sensible path the docs point to rather than a tested walkthrough.
- Pick one decision your workflow makes constantly. Route, flag, or score — a ticket router, a lead scorer, a risky-action check. One decision, high volume.
- Define the options as a schema. Write out the exact choices, levels, or yes/no statement. If you cannot enumerate the options, it is not a Jev problem yet.
- Wire Jev to answer just that. One classifier, one state in, one typed answer out. Run it beside your existing logic rather than replacing anything on day one.
- Watch the confidence scores before trusting it end-to-end. Log Jev's answers against what your current system decided. When the probabilities hold up on your data, flip the switch.
Same crawl-walk-run discipline as the Agent OS guide: instrument first, automate second.
Honest Limits Before You Commit
TypeSafe's launch post is upfront about what Jev will not do, and you should be too:
- No free-form text generation. Jev cannot write a sentence. Summaries, replies, and explanations still need your LLM.
- 255 choices max per query. Above that, TypeSafe describes a two-stage scoring approach — so a taxonomy with thousands of labels needs planning up front.
- Structured state only. Jev judges exactly what you send it. Sloppy state in, confidently wrong answers out.
- Early access. Waitlist pacing is TypeSafe's call, per the launch post, so do not architect a launch around access you do not have yet.
Jev FAQ
Do I need the waitlist?
Yes. Per TypeSafe AI's launch post, Jev opened for early access on 15 September 2026, and developers come off the waitlist as fast as TypeSafe can manage. Sign up at typesafe.ai, then create your key at console.typesafe.ai once your invite lands.
Can Jev replace my LLM?
No, and it is not trying to. Jev makes decisions; it cannot generate a word of text. The play, per LangChain's guide, is replacing LLM calls on straightforward classification — routing, screening, scoring — while your LLM keeps every generative job.
What does Jev cost?
Per the launch post: $0.042 per million input tokens, and output is free. Combined with 70–500ms responses, Jev is priced to sit on the hot path of every single request.
Where does Jev fit in an agent stack?
The critic and screening seats: routing requests by complexity, screening tool calls for risk before they run, scoring outputs against your rubric. Generation stays with your LLM — Jev decides, your LLM writes.
Get Jev Working in Your Stack
That is how to use Jev end to end: waitlist at typesafe.ai, key from console.typesafe.ai, install langchain-typesafe, set TYPESAFE_API_KEY, then send a state with Choice, Score, and Noul questions and branch on the probabilities that come back. Start with one high-volume decision and let the confidence scores earn your trust.
Want to build it alongside people shipping agent systems every week? Join us in AI Profit Boardroom — $69/mo locked in (normally $110), with 3,000+ members pressure-testing exactly these routing and screening patterns. Prefer to map your specific use case one-on-one first? Book a free strategy session and we will design your first Jev classifier together.
