Jev — classify without paying an LLM every turn

An agent is a loop: the LLM decides, a tool runs, you re-evaluate, repeat. Tool calling and structured output made that pluggable into real software. The cost didn’t move: every micro-decision — urgent or not, cheap model or large, dangerous bash or not — still fires a chat forward. Sydney Runkle and Hunter Lovell (LangChain, 17 Sep 2026) drop Jev exactly there. Not another LLM. A classifier built for the harness.

The LangChain post →

Why I care

Cursor, Claude Code, Codex: they all classify before a dangerous tool. That’s what makes auto-mode livable. And it stayed in the closed part of the harness. The moment you build your own — Hermes, LangGraph, a chaining MCP — you pay an LLM for yes/no. Jev hits that: a calibrated decision, not a sentence.

• TypeSafe claims up to ~200× faster and ~400× cheaper than comparable LLMs on classification (their System One benches: 193.6× / 444.6×).
• List price: $42 per billion input tokens — 238× under Claude Fable 5.1 on input.
• It doesn’t generate text. Your code reads a probability and a threshold, then acts.

What Jev actually is

TypeSafe calls it a System One model: you send a *state* (text, JSON, LangChain messages) and *questions*. You get typed answers plus calibrated confidence. Training: RLCD (reinforcement learning for calibrated decisions), not chat RLHF. The model isn’t trying to please you. It estimates P(statement).

Three question types, several in parallel on the same state — latency barely moves, you mostly pay the question tokens:

• Noul — yes/no. Returns noul ∈ [0, 1]: probability the statement is true.
• Choice — one option from a set. Distribution plus a confidence score.
• Score — an ordered level (low / medium / high). Continuous score plus distribution.

Their docs’ support example: a Stripe ticket failing for three days, “I’m losing sales” → is_urgent.noul = 0.999. Your router prioritizes. No paragraph. No “I think”.

In LangChain

langchain-typesafe does not expose a chat model. It’s a `TypeSafeClassifier`. You .invoke() state + questions, you read response.nouls[...].

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

Two experimental middlewares map onto a harness:

• `ModelRouterMiddleware` — Jev reads the latest message, picks fast vs powerful from your criteria. A lookup no longer pays for a Sol.
• `AutoModeMiddleware` — Jev inspects the tool call (e.g. bash) and blocks before execution if risk crosses the threshold. The Cursor/Claude pattern, open, on any create_agent.

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import AutoModeMiddleware

guardrail = AutoModeMiddleware(tools=["bash"])
agent = create_agent("openai:gpt-5.6-luna", middleware=[guardrail])

Where it lands in my stack

On Hermes, a long session’s cost is no longer the big reasoning pass. It’s the hundreds of classifs around it: is this the right skill, is this shell safe, do I wake a 27B. Jev is the piece I’d put *in front of* the model — local or API — not instead of it. LivingColor, MCP review, mail triage: the LLM writes and plans; Jev says yes/no fast enough not to stall the loop.

Takeaway

Jev is not a rival to Qwen 3.8. It’s the layer harnesses kept private: a calibrated classifier, cheap enough to run on every tool call. TypeSafe sells the System One story (machines, not chat). LangChain makes it pluggable tomorrow morning. The real test is an AutoModeMiddleware on an agent that already has bash — and watching what it refuses, not the blog.

• Source: langchain.com/blog/building-a-harness-with-jev
• TypeSafe: typesafe.ai
• Package: langchain-typesafe
• Hermes: /blog/hermes-automation-cheaper-models