Jev: Taking Agent Decisions Out of Text Generation

Many agents do not fail because they cannot write an answer. They fail because every small decision is produced as prose and then parsed: should this run, which candidate wins, and how confident is the model? Jev takes the opposite route. Given a state, typed questions, and candidates, it returns typed decisions directly.

What Jev is

TypeSafe AI describes Jev as a System One model. It is neither a chat model nor a browser automation framework. A request contains state plus typed questions; the response can be a Choice, Score, or Noul-style yes/no/uncertain judgment with probabilities. Jev's hosted model and weights are closed. Open-Jev is an independent reproduction and should not be presented as official open weights.

That boundary makes the fit clear: routing, filtering, approval gates, tool selection, grading, and workflow branches belong here. Long-form writing, code generation, and open-ended planning still belong to a general LLM.

The key idea: define the output space first

An abstract call looks like this:

result = client.ask(
    state="The package arrived damaged and the customer asks for a refund",
    questions={
        "refund_requested": {"type": "noul"},
        "route": {"type": "choice", "criteria": {"billing": "refunds", "support": "delivery"}},
        "frustration": {"type": "score", "criteria": ["calm", "upset", "severe"]},
    },
)

The application defines the question types and candidates first. The model chooses inside that space. This removes a class of failures involving JSON parsing, enum spelling, extra fields, and invented tool names. A probability is not a proof of correctness: it is a signal for thresholds, review, and model routing, and still needs calibration data and abstention policy.

Comparison with open-source routes

OpenAI/Anthropic structured tool calling makes a general model produce a schema-conforming call. It is broad, but still starts with autoregressive generation followed by constrained parsing. Jev makes the judgment itself the service, which is useful for frequent small decisions; the trade-off is that the question must be typed in advance.

Open-Jev publishes 2B, 9B, and 27B-v1.1 LoRA packages, a decision head, calibration temperature, datasets, and a workbench. Its README describes a self-hostable research route: a base model supplies representations, a trained scalar decision head scores candidates, and temperature parameters calibrate probabilities. It also explicitly says that it does not reproduce TypeSafe's private RLCD, weights, or training data, so it is a research baseline rather than an official clone.

browser-use and BrowserGym/OSWorld solve a different layer: observing a browser and executing actions. They provide browser state, DOM/screenshots, action drivers, and evaluation environments. Jev can sit inside that stack to decide whether confirmation is needed, which candidate to click, or whether a task is complete; it does not replace the browser driver.

SWE-agent, OpenHands, and Hermes are fuller agents with loops, tools, terminals, memory, permissions, and recovery. Jev fits as a fast gate: filter tool candidates, estimate risk, or decide whether to escalate to an expensive reasoning model before the main agent acts.

A practical composition

Split an agent turn into state reduction, Jev gating, main-model planning, and execution with verification. Do not send an entire HTML page or log archive as state. An adapter should extract stable features: candidate tools, target entities, risk labels, the previous result, and observable completion conditions. The decision then feeds an explicit policy: ask for review below a threshold, escalate close candidates to the main model, and terminate a branch on an explicit refusal.

This is more precise than calling Jev a faster GPT. Its value comes from an interface contract and a latency budget. Narrow, frequent, high-cost decisions benefit most; long explanations, new code, and open-world research still need a general model.

Self-hosting and evaluation

For a fully controlled private deployment, Open-Jev is a useful research starting point, but pin the base-model revision, candidate order, context length, and calibration temperature. Measure more than top-1 accuracy: calibration, abstention quality, sensitivity to candidate changes, P50/P95 latency, and business cost of wrong decisions. “Picked correctly” and “probability is trustworthy” are different properties; the latter is what makes automatic release safe.

The main lesson is not to build a larger chat model. It is to turn implicit Agent if/else branches into observable, calibrated, replaceable decision interfaces. A hosted API, Open-Jev, a classifier, and a rules engine can then share one contract, while expensive generation is reserved for the steps that actually need it.

Technical references: TypeSafe Jev projects, Jev Agent API guide, Open-Jev source and models, BrowserGym, browser-use, and OpenHands.