The Jev AI API takes a state plus questions and returns typed decisions with calibrated probabilities — and you can reach it three ways right now: TypeSafe's console (waitlist early access), the langchain-typesafe package, or Vercel's AI Gateway, where it is free until 25 September 2026.
📺 Watch: How to Use Jev AI for FREE!
🔥 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 is the entire model. You do not prompt it into behaving. You do not parse text and pray. You send data, you ask questions about that data, and you get back typed answers with a probability attached to each one — which means your code finally knows how confident the model is before it acts.
This guide covers the request model, all three access routes, the honest limits, and the first patterns worth building. If you are still working out what Jev actually is and where it came from, read the Jev AI overview first, then come back — this page is pure API.
Jev AI API: The Request Model Explained
Every request you send the Jev API has two parts: a state and questions.
The state is the thing you want analysed. It can be plain text, structured data, or a stack of messages — a support ticket, a scraped page, a call transcript, a lead form. The questions are the decisions you want made about that state. Per TypeSafe's official launch (15 September 2026) and LangChain's integration guide, answers come back as typed fields with probabilities, never as generated text.
Three question types cover everything you will build:
| Question type | What it asks | What you get back |
|---|---|---|
| Choice | Pick one option from a list you supply | A probability for every option, plus an overall confidence number |
| Score | Rate the state against ordered levels you define | A continuous score plus a distribution across your levels |
| Noul | A straight yes or no | A single probability that the answer is true |
The performance detail that changes your architecture: every question in a request processes in parallel. Ask ten questions about one state and it costs roughly the time of one. End-to-end responses land in 70 to 500 milliseconds, which is fast enough to sit inside a live user flow — not just an overnight batch job.
Members inside AI Profit Boardroom — 3,000+ members building with agents daily — have been swapping Jev workflows since launch week. If you want working setups instead of theory, that is where they live.
Route 1: The TypeSafe Console (Waitlist Early Access)
The first route into the Jev API is straight from the source. TypeSafe opened early access on 15 September 2026, gated behind a waitlist. Once you are approved, everything runs through the console at console.typesafe.ai — your key, your usage, your billing, in one place.
Pricing is the strange part, in a good way. Input costs $0.042 per million tokens. Output is free. That sounds like a typo until you remember what this API returns: probabilities and typed fields, not essays. There is barely any output to charge for. I break down what that means against mainstream model pricing in the Jev pricing guide.
If you are not in a hurry, join the waitlist and wait for your key. If you want to build today, route 3 skips the queue entirely.
📺 Watch: Hermes + North Mini Code: New FREE API!
Route 2: The langchain-typesafe Package
Already building in the LangChain ecosystem? This is your fastest path to production with Jev. Install the langchain-typesafe package, set the TYPESAFE_API_KEY environment variable to your key, and you are connected.
The flow from there is simple to describe in plain English: you create a classifier, hand it the labels or levels you care about, and invoke it against your state. The package wraps Jev's question types so they behave like any other LangChain component — they slot into the chains and agents you already run, and the typed answers flow through with their probabilities intact.
LangChain also shipped a ready-made model router built on Jev. You describe each model's strengths in plain English — this one is cheap and fast, this one is strong on code, this one handles huge context — and Jev routes every incoming request to whichever model fits best. Under the hood that is just a Choice question, answered in well under a second.
📺 Watch: NEW Fusion API Is Absolutely INSANE!
Route 3: Vercel AI Gateway (Free Until 25 September 2026)
This is the route I covered in my video "How to Use Jev AI for FREE!" on 20 September 2026 — and it is the route to take this week, because the free window on Vercel's AI Gateway closes on 25 September 2026.
Setup takes minutes. Grab an API key from the quick start in your Vercel settings, point the AI SDK at the gateway, and start sending states and questions. One honest note from my own run: Vercel asked for a card on file even though usage stayed free. Mildly annoying, but the meter genuinely stayed at zero for me.
Here is the tip most people miss: you do not have to wire any of this up yourself. Paste the documentation and your API key into Claude — or better, set the key as an environment variable so it never touches the chat — and let the coding agent build the integration for you. I have confirmed this handoff works from Hermes, from Claude running Fable 5, and from Codex. If working through agents is new to you, my Agent OS guide shows the setup that makes it routine.
Want the click-by-click version of all three routes? That is the how to use Jev walkthrough.
The Limits of the Jev API, Honestly
Before you architect anything around this API, three real constraints from the official documentation:
- No free-form text output. Jev cannot write a sentence, a summary, or an apology email. It decides; it does not generate. Every serious build pairs it with a generator model.
- 255 choices maximum per query. Need to pick from 4,000 products? Run a two-stage setup — score candidates in batches first, then push the finalists through a single Choice question.
- Structured state only. Text, structured data, and messages are in. Image input is not documented, so treat vision as off the table for now.
Jev decides. Your other models generate. Keep that split in your head and every pattern below falls into place.
None of these limits are dealbreakers — they are the definition of the tool. And apply the same scepticism here that you would anywhere else. I pressure-test model claims on Goldie Bench before I trust them, and you should run your own numbers on the Jev API before it touches production.
The First Patterns Worth Building With Jev
Confidence thresholds. This is the pattern that makes calibrated probabilities pay. Pick a line. Above it, your system acts automatically. Below it, a human decides. The voice-browser project built on Jev does exactly this — any click decision under 0.45 confidence triggers numbered badges on the page so the user picks instead of the machine guessing.
Guardrails on LLM output. This is TypeSafe's official flagship use case for the API. Your big model generates; Jev verifies. Is this response on-topic, yes or no? Does it break policy? You get a probability for each check in a fraction of a second, cheap enough to run on every single output.
Routing and screening. Straight from the LangChain patterns: route requests to the right model, screen leads before they hit your calendar, triage tickets before a human reads them. Anywhere you currently pay a slow, expensive model to make a small decision, the Jev API is the swap.
One more from my own builds, so take it as my claim rather than gospel: I pair Jev with a heavyweight model — Fable 5 or Astra — and hand every yes-or-no and pick-one decision to Jev. The big model burns dramatically fewer tokens because it is no longer doing the deciding. If you want the full architecture around that, read the Jev AI agent build.
Not sure which pattern fits your business first? Book a free strategy session and I will map it with you.
FAQ: The Jev AI API
How do I get a Jev API key?
Three ways. Join the TypeSafe waitlist and manage your key at console.typesafe.ai once approved. Generate one through the quick start in your Vercel settings for the AI Gateway route — the fastest option while the free window runs. Or plug a key into the langchain-typesafe package by setting it as the TYPESAFE_API_KEY environment variable.
Is there a free Jev API?
Right now, yes. Vercel's AI Gateway carries Jev free until 25 September 2026 — you will need a card on file, but usage cost me nothing during testing. After the window closes, TypeSafe's direct pricing applies: $0.042 per million input tokens, with output free.
Can Jev return text?
No, and that is deliberate. The API returns typed decisions only — choices, scores, and yes-or-no answers, each with a calibrated probability. If you need prose, keep a generator model in the loop and let Jev handle the verification and routing around it.
How fast is the Jev API?
Official figures put responses at 70 to 500 milliseconds end to end, and every question in a request runs in parallel — so ten questions about one state cost roughly the time of one.
Ship Something Before the Free Window Closes
You have three routes into the Jev AI API, and one of them is free for a few more days. Pick a workflow with an obvious decision in it, hand the gateway docs and your key to a coding agent, and ship a confidence-thresholded version of it this week.
If you want to build it alongside people who ship daily, join AI Profit Boardroom — 3,000+ members, live builds every week, and the price locks at $69 a month (normally $110) for as long as you stay. Prefer one-on-one? Grab a free strategy session and we will design your first decision layer together.
