You don’t need to know anything about AI to understand this one.
Start here: a simple way to picture it
Imagine you have two employees.
Employee A is brilliant. You can hand them a messy situation and they’ll think it through, write you a thoughtful email, explain their reasoning, have a conversation with you about it. But they’re a little slow, and it costs you real money every time you ask them something.
Employee B doesn’t talk. Ever. But you can hand them any situation and ask, “billing or technical?”, “how urgent, 1 to 5?”, “is this person angry?” — and in a split second, they hand you back a sticky note with the answer, plus how sure they are about it. No conversation, no paragraph, just the answer.
Most AI today — ChatGPT, Claude, Gemini — is Employee A. Brilliant, but built to talk.
Jev, a new AI model from a company called TypeSafe, is Employee B. It’s built to decide, not to talk.
That’s really the whole idea. Everything else in this article is just examples of why that difference turns out to matter a lot.
Why would anyone want an AI that can’t talk?
Here’s the thing most people don’t realize: a huge amount of what companies use “talking” AI for isn’t actually about talking at all.
When your bank’s app decides whether to flag a transaction as fraud, that’s not a conversation — it’s a yes/no decision. When a support ticket gets routed to “billing” instead of “technical,” that’s not a conversation — it’s a multiple-choice pick. When an app decides “this request is urgent, escalate it,” that’s a decision, not a sentence.
For years, companies have been using chat-style AI (like ChatGPT) to make these decisions anyway, because it was the only AI available. They’d basically ask the chatbot, “Please answer only with the word ‘billing’ or ‘technical’, nothing else” — and hope it listened. Sometimes it adds a sentence of explanation anyway. Sometimes it formats things slightly wrong. It works, but it’s a bit like hiring a novelist to fill out a multiple-choice form. They can do it, but it’s not really what they’re built for, and it’s slower and pricier than it needs to be.
Jev is what happens when someone builds an AI specifically for the multiple-choice form instead.
It doesn’t write sentences. It takes in a situation, and for each yes/no question, rating, or multiple-choice question you give it, it gives you back a clean answer — instantly, and cheaply — along with how confident it is.
A real-world example anyone can picture
Say you message a company’s support chat: “I was charged twice, please refund me.”
Behind the scenes, something has to figure out:
- Which department should handle this? (billing? technical?)
- How urgent is it?
- Is this person actually asking for a refund, or just venting?
With old-school chat AI, the company’s system quietly asks a chatbot those questions in the background and tries to read its written answer.
With Jev, the system just asks those three questions directly, and gets back:
- Department: billing (97% sure)
- Urgency: 5 out of 5 (93% sure)
- Refund request: yes, 98% likely
No sentence was ever generated. No one had to “read” anything. The computer just got numbers and labels it can act on immediately — send to the billing team, mark it urgent, start the refund process.
That’s it. That’s the whole trick: skip the talking, go straight to the decision.
Why does this even matter to a regular person?
Even if you never build software yourself, this affects you constantly without you noticing:
- Faster customer support routing (less time in a queue)
- Faster fraud checks on your card
- Cheaper AI-powered apps overall, because decision-only AI is far cheaper to run than a full conversational one for tasks that don’t need conversation
- Potentially more honest AI in places that matter — because Jev tells you its confidence, an app can be built to say “I’m not sure, let a human handle this” instead of guessing and pretending it’s certain
The bigger cultural point: not every “smart” task actually needs a system that can hold a conversation. A huge amount of what we’ve been calling “AI” is really just judgment calls dressed up as conversations, because talking AI was all we had. Jev is a bet that once you build the right tool for judgment calls, a lot of software gets faster, cheaper, and more predictable.
For AI engineers: where Jev actually changes your stack
If you’re already building with RAG pipelines, agents, MCP, or multi-agent systems, the “employee who doesn’t talk” framing undersells how much this reshapes your architecture. Here’s the more useful version.
RAG pipelines
Most RAG systems quietly burn LLM calls on decisions that aren’t really retrieval or generation:
- Retrieval gating: “Is the retrieved context actually relevant to this query?” is usually either skipped (hurting accuracy) or done with an LLM call that adds latency before the real generation even starts. Jev can sit between retrieval and generation as a cheap Noul check — “this chunk is relevant” — filtering weak context out before it ever reaches your expensive generation model.
- Query routing across knowledge bases: if you’re routing a query to one of several vector stores or indices (support docs vs. legal vs. product specs), that’s a Choice question, not a generation task. Doing it with Jev instead of a routing prompt removes a full LLM round-trip from your critical path.
- Chunk quality / PII triage on ingestion: at ingestion time, “is this document type X,” “is it legible,” “does it contain PII” are exactly the kind of parallel Noul/Choice batch Jev is built for, and it’s a natural fit for high-volume ingestion pipelines where you’re currently either skipping this triage or paying LLM prices for it.
The mental shift: retrieval quality control becomes a Jev layer, not a prompt-engineering problem.
AI agents
Every agent loop is full of judgment calls hiding inside the reasoning step: which tool to call, whether an action is safe to execute, whether to retry or escalate, whether the observation actually answered the question. Right now, most of that judgment happens inside the same LLM call that’s doing the actual reasoning — which means your reasoning model is context-switching between “think deeply” and “make a snap call,” and you can’t independently inspect or tune the snap calls.
Splitting them out changes a few things concretely:
- Pre-action guardrails become explicit and testable. Instead of trusting the agent’s own judgment on “is this action safe,” you get a separate Noul confidence score you can threshold on and log — e.g., block any tool call with
is_reversible.noul < 0.9without an approval step. - Retry/escalate logic moves from implicit to explicit. “Did this tool call actually succeed at the intended goal” is a Score or Noul question you can run after every tool result, independent of whatever the agent’s next reasoning step concludes.
- You get observability you didn’t have before. Confidence scores and probability distributions on every gating decision mean you can log drift over time — is the agent becoming less confident about a certain action type as your product changes? That’s invisible when judgment is buried inside free-text reasoning traces.
The mental shift: the agent’s “reflexes” (gate, check, score, route) become a separate, inspectable layer from its “reasoning.”
MCP (Model Context Protocol)
MCP servers expose tools to models, but they don’t solve the problem of which tool, when, or whether it’s safe to call it right now — that’s still left to the calling model’s judgment. In a Jev-augmented setup:
- Before an MCP tool call executes, a Jev Noul check (“this tool call matches the user’s stated intent” / “this write operation is authorized for this session”) can act as a policy layer sitting between the agent and the MCP server — independent of whichever LLM is orchestrating the call.
- When multiple MCP servers expose similar tools (e.g., two different calendar integrations), tool selection is a Choice problem, and routing it through Jev instead of an LLM prompt keeps tool selection fast and cheap even as your MCP tool surface grows.
The mental shift: MCP gives models access to tools; Jev-style gating gives you a policy layer that governs when that access is actually used — a distinction that matters a lot once you’re exposing write-capable tools, not just read-only ones.
Multi-agent systems
This is arguably where the “decision layer” idea compounds the most, because multi-agent systems are, structurally, one long chain of routing and handoff decisions: which sub-agent handles this sub-task, has this sub-agent actually finished, should we escalate to a supervisor agent, is this a case for human-in-the-loop.
Today, a lot of multi-agent frameworks handle this with a “supervisor” or “orchestrator” LLM whose entire job is basically classification wearing a reasoning costume. Swapping that orchestration layer’s routing decisions (not its planning) over to Jev:
- Cuts the latency and cost of every handoff, which matters a lot when a task might bounce between 4–5 sub-agents before completion.
- Makes the handoff logic testable and versionable — a coefficient or threshold you can change, rather than a supervisor prompt you have to re-tune every time you add a new sub-agent.
- Gives you a confidence signal at every handoff boundary, so you can build in fallback behavior (“if routing confidence is below 0.7, ask a human which agent should take this”) instead of silently letting a low-confidence routing decision cascade through the whole system.
The mental shift: orchestration logic in multi-agent systems is mostly a sequence of Choice/Score/Noul decisions wearing a “supervisor agent” costume — and it’s one of the clearest places to swap in a dedicated decision layer instead of an LLM-based orchestrator.
The one-line takeaway for engineers
If you already work with RAG, agents, MCP, or multi-agent orchestration, you already have a decision layer in your system today — it’s just hidden inside prompts, buried in orchestrator LLM calls, or skipped entirely for cost reasons. Jev’s pitch isn’t “add a new capability,” it’s “pull the decision layer you already have out into the open, where you can test it, threshold it, and watch it drift over time.”
How do you actually call Jev? (The practical part)
If you’re an AI engineer, the first real question isn’t philosophical — it’s “how do I hit this thing.” Short answer: yes, it’s API-key based, same as any other model provider. But it’s not a drop-in chat API, and that trips people up.
It’s a separate model, with its own endpoint — not OpenAI-compatible.
You get an API key from TypeSafe’s console, the same way you’d get one from any LLM provider. But instead of hitting /chat/completions with a messages array, you hit a dedicated endpoint — POST https://api.typesafe.ai/v1/systemone — with a state (your context) and a questions object (your Choice / Score / Noul definitions). No temperature, no streaming tokens, no messages array. Pointing an existing OpenAI-style client at it simply won’t work; it’s its own contract.
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
with TypeSafeClient() as client: # reads TYPESAFE_API_KEY from env
response = client.system_one(
state={"ticket": "I was charged twice and need a refund today."},
questions={
"intent": Choice(
instructions="What is the customer's main request?",
criteria={
"refund": "The customer wants money returned.",
"technical_help": "The customer needs a bug fixed.",
"other": "None of the above.",
},
),
"is_urgent": Noul(instructions="Does the ticket express time pressure?"),
},
)
print(response.intent.choice, response.intent.confidence)
print(response.is_urgent.noul)
The direct API is currently waitlisted. If you don’t want to wait, a few gateways already serve Jev without one — useful if your team already centralizes model calls through a gateway:
| Route | Waitlist? | How you call it |
|---|---|---|
| TypeSafe direct | Yes | Native SDK, own API key |
| Vercel AI Gateway | No | experimental_evaluate, model id typesafe-ai/jev |
| Cloudflare Workers AI | No | env.AI.run("typesafe/jev", ...) |
| OpenRouter | No | Their newer “decisions” endpoint, model typesafe/jev-1.13 — not their usual chat-completions endpoint |
Pricing: roughly $0.04 per 1M input tokens, and output is free — which makes sense, since there’s no generated text on the way out, just a typed answer.
A simple proof of concept: adding Jev to a RAG chatbot
The fastest way to feel the difference is to take a RAG chatbot you already have and slot Jev in at two points, without touching your existing LLM call at all.
Picture a basic RAG chatbot: user asks a question → you retrieve relevant chunks from a vector store → you pass those chunks plus the question to your LLM → the LLM writes an answer.
Here’s where Jev fits, as two extra (and independent) calls around that same pipeline:
Step 1 — Before generation: is the retrieved context actually good enough to answer from?
retrieved_chunks = vector_store.search(user_question, top_k=3)
relevance_check = jev_client.system_one(
state={"question": user_question, "context": retrieved_chunks},
questions={
"context_is_relevant": Noul(
instructions="Does the context contain information that answers the question?"
),
},
)
if relevance_check.context_is_relevant.noul < 0.6:
# Don't even call the LLM — retrieval failed
return "I couldn't find enough information to answer that confidently."
This alone fixes a common RAG failure mode: instead of letting the LLM confidently hallucinate an answer from weak or irrelevant chunks, you catch it before generation even starts — and you skip the (more expensive) LLM call entirely when it wouldn’t have helped anyway.
Step 2 — After generation: is the answer actually grounded in the retrieved context, or did the LLM drift?
llm_answer = your_llm.generate(question=user_question, context=retrieved_chunks)
groundedness_check = jev_client.system_one(
state={"answer": llm_answer, "context": retrieved_chunks},
questions={
"is_grounded": Noul(
instructions="Is this answer fully supported by the provided context, with no unsupported claims?"
),
"needs_human_review": Choice(
instructions="Should this answer be shown directly, flagged for review, or blocked?",
criteria={
"show": "Answer is well-grounded and safe to show as-is.",
"flag": "Answer is mostly fine but worth a human spot-check.",
"block": "Answer contains unsupported or risky claims.",
},
),
},
)
if groundedness_check.needs_human_review.choice == "block":
return "I'm not confident enough in this answer — let me get a human to help."
What you just built, in plain terms: your LLM still does 100% of the actual writing and reasoning — nothing about your generation call changed. But now you have a cheap, fast checkpoint before generation (don’t bother answering from bad context) and after generation (don’t show an answer that drifted from the source material) — both running as separate, parallel, typed decisions instead of extra prompts stuffed into your main LLM call or a second expensive LLM call just to “check its own work.”
That’s the pattern worth taking away, whether or not you ever touch Jev specifically: treat retrieval quality control and answer verification as decision-layer problems, not generation problems — and reach for a dedicated decision model instead of asking your generation model to also grade its own homework.