Neo Tang

Posted on Sep 21 AI-assisted

Jev Isn't a Chatbot — It's a System One Model for Typed Decisions

#ai #agents #llm #architecture

If you've built agents in 2025–2026, you already know the awkward middle:

Hand-written if rules are too brittle for fuzzy judgments ("is this urgent?", "which team?", "is this tool call safe?").
A frontier LLM can answer those questions — but it's slow, expensive, and returns prose you still have to parse.

Jev (from TypeSafe AI) is aimed squarely at that gap. It doesn't write essays. It reads your program's state and returns typed, calibrated decisions your code can branch on immediately.

This post is a practical intro for indie / SaaS builders who want the mental model, a first API call, and a few real patterns — not a press release.

What Jev actually is

TypeSafe calls Jev a System One model.

Think Kahneman: System Two is slow, verbal reasoning (what chat LLMs imitate). System One is the fast gut check. Jev is built for the software version of that gut check — routing, scoring, filtering, gating — at high volume.

You send:

state — the context (ticket text, JSON event, agent messages, …)
questions — one or more typed questions about that state

You get back structured answers with probabilities. No free-text. No "sorry, as an AI…" preamble.

Training focus is RLCD (Reinforcement Learning for Calibrated Decisions): when Jev says ~80% confidence, the goal is that it's right about ~80% of the time. That calibration is what makes thresholds usable in production instead of vibes-based prompt engineering.

Three question types (that's the whole surface)

Type	What you ask	What you get back
choice	Pick 1 of up to 255 labelled options	Winning key + per-option probabilities + confidence
score	Place input on an ordered 2–10 level scale	Fractional score + distribution
noul	Yes/no as a probability	`noul` in `[0, 1]`

You can ask several questions in one request. They evaluate in parallel and share the state cost — so batching beats a loop of tiny calls.

Tiny example: urgency gate

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

A typical answer looks like:

{
  "is_urgent": {
    "type": "noul",
    "noul": 0.999
  }
}

Then your code stays boring (in a good way):

if (answers.is_urgent.noul > 0.7) {
  escalate(ticket);
}

No regex. No JSON-schema-from-an-LLM-that-sometimes-breaks. The type is fixed by the request.

Why this matters for agents (not just classifiers)

Agents spend most of their loop on tiny judgments:

Is this still needed?
Which model should handle this turn?
Is this tool call too risky?
Which queue should own this event?

Those used to be either brittle rules or another LLM round-trip. Jev is the middle lane: fast enough for the hot path, structured enough for code.

Public numbers TypeSafe / ecosystem write-ups commonly cite:

Latency roughly 70–500ms
Far cheaper than frontier LLMs on comparable classification-style tasks (pricing differs between direct TypeSafe access and hosted gateways — check the console you use)
Output tokens free on the decision API shape (you pay for input / state)

Use an LLM for generation and open-ended reasoning. Use Jev for the decisions around that generation.

Patterns that actually ship

1. Ticket / email triage

One state, multiple questions: route (choice), urgency (noul), lead quality (score). Auto-handle high-confidence cases; escalate the uncertain band.

2. Model routing

Ask Jev which tier should run this turn ("fast lookup" vs "architecture / high-stakes"). LangChain's experimental ModelRouterMiddleware is built around this idea.

3. Tool-call guardrails ("auto mode")

Before bash / delete / payment tools execute, ask a noul: "is this risky / irreversible?" Block or confirm when probability is high. Same pattern coding harnesses already use — now available as a cheap, open classifier layer.

4. Indie product glue

If you run SEO tools, support inboxes, or agent workflows (hello, build-in-public SaaS), Jev is a good fit anywhere you currently:

prompt an LLM just to get a label, or
maintain a growing pile of keyword heuristics

LangChain sketch

from langchain_typesafe import Noul, TypeSafeClassifier

classifier = TypeSafeClassifier()

response = classifier.invoke({
    "state": (
        "The deploy failed twice and customers are seeing 500s. "
        "Can someone look now?"
    ),
    "questions": {
        "urgent": Noul(instructions="Does this need attention right now?"),
    },
})

urgency = response.nouls["urgent"].noul

State can be text, structured data, or LangChain messages — handy inside middleware / nodes.

Ecosystem tips (beyond the core API)

The community moved fast after launch:

awesome-jev / jev-mcp style tooling around MCP clients
jevlang — Python "smart if" syntax for decision workflows
jev-router — route Claude Code / Codex turns to cheaper vs stronger models
browser / automation pilots that treat Jev as the chooser, not the writer

If you're exploring for a weekend project, start with one noul gate in an existing script. Don't rebuild your whole agent day one.

Practical gotchas

Pin model versions in production (jev-1.x.x) if thresholds matter — jev-latest can shift.
Batch questions on shared state instead of N sequential calls.
Use confidence / probability bands: auto-approve high certainty, human or LLM escalate the middle.
Jev is not a chat UX. Don't put it in front of end users as a conversational product. Put it inside the product.
Access paths vary (TypeSafe waitlist / console, gateways like OpenRouter / Vercel AI Gateway, or hosted metered keys). Pick one and keep the key server-side only.

Who's behind it (short)

TypeSafe AI was founded by Diogo Almeida (ex-OpenAI, co-inventor work around RLHF), with Erik Gafni and Sasha Sheng. The company came out of stealth in September 2026. The thesis is blunt: if AI is going to change work, people can't be the only consumers of intelligence — most of it should live quietly in software.

Bottom line

Jev won't write your README. It will decide, in under half a second, whether this ticket is urgent, which team owns it, and whether your agent should be allowed to run that delete.

For indie builders drowning in "tiny LLM calls that only return a label," that might be the most useful new primitive of the season.

DEV Community