Routing lathe jobs with Jev: typed decisions, no chatbot

The client runs a lathe shop, a dozen machines, small batches, and a dispatcher who spent his mornings sequencing jobs against machine states, tooling, and due dates on a whiteboard. My part was the software around him. The interesting decision in that software is one line: which machine eats which job next. Get it wrong and an idle spindle waits while a due date burns.

We put a model into that loop recently. Not a chat model. The model that fit was the one that cannot write a sentence.

What is Jev, actually?#

Jev is the first public model from TypeSafe AI, a San Francisco lab that came out of stealth this month, and it belongs to a class the company calls System One models (announcement). The founder, Diogo Almeida, writes that he worked at OpenAI on the methods behind ChatGPT before leaving to build this. A System One model does not generate text. You send it a state, any unstructured context, and typed questions about that state, and it returns typed answers with probabilities (concepts documentation).

There are three question types. Choice picks from options you define and comes back with the pick, a probability for every option, and a confidence value. Score rates a state against ordered levels. Noul answers a yes or no question with a probability. Questions in one request are evaluated in parallel, so three judgments cost barely more than one (Choice documentation).

The vendor numbers are vendor numbers. Input at $0.042 per million tokens, outputs free, end-to-end response between 70 and 500 milliseconds, and homepage claims of 193.6x faster and 444.6x cheaper on their own workflow evals, which the announcement itself calls the higher end of real-world gains. Within two weeks of launch there were hackathons, a LangChain write-up, and a pile of community projects (LangChain). Independent measurement barely exists yet. Treat all of it accordingly.

Why the chat model was the wrong shape for dispatch#

Dispatch is not a conversation. A job event fires, the router needs an answer inside the same tick, and the answer has to slot into code that assigns a queue position. A chat model gives you a string: parse it, validate it, handle the day it refuses or rambles. Seconds of latency per decision, real money per call, and a confidence estimate the announcement's own comparison table calls overconfident and inconsistent.

This is the same discipline I already run on the support agent here: everything a model returns gets validated against a schema before it touches state. Jev moves the contract inside the model call. The answer is typed because the question was typed, and the hot path has one less place to surprise anyone.

The routing call itself#

The whole decision is one call. The state is a plain paragraph the dispatcher would recognize, built from the machine logs and the order notes, and the questions carry the shop's actual policy (quickstart):

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
 
client = TypeSafeClient()
 
response = client.system_one(
    state=dispatch_state(job, machines, order_notes),
    questions={
        "machine": Choice(
            instructions="Which machine should take this job next",
            criteria={
                "machine_a": "Idle, 3-jaw chuck mounted, low spindle hours",
                "machine_b": "Free after noon, same batch family running",
                "machine_c": "Idle but uncalibrated after the crash",
                "hold": "No machine is a defensible fit today",
            },
        ),
        "rush": Noul(
            instructions="The order notes justify moving this job ahead",
        ),
        "setup_risk": Score(
            instructions="Risk that the assigned setup delays the due date",
            criteria=[
                "Low, standard tooling fits",
                "Medium, minor changes needed",
                "High, fresh setup required",
            ],
        ),
    },
)
 
pick = response.answers["machine"]  # .choice, .probabilities, .confidence

The answer arrives with its choice, the full probability distribution, and a confidence number. The hold option is the honest one: it lets the model say that no machine is a defensible fit, which a heuristic queue cannot say at all.

The confidence number is the feature#

Confidence is computed from the spread of that distribution: a single peak means sure, a flat shape means torn. That number made the system deployable. Below a threshold the router does not guess, it parks the job in the planner's queue with the probabilities attached. The state includes human notes, exactly the kind of untrusted text I would not let influence anything directly (the fetch guards post); here its influence is bounded by the answer types.

The log turned out to be the second deliverable. Every decision lands with its confidence, and the weekly review of low-confidence cases is how the option descriptions got tuned. The documentation is careful about the limit: calibration is measured across groups of predictions and does not guarantee any individual answer. The threshold follows from that sentence.

Where a person stays in the loop#

The machine side never changed. Interlocks, spindle limits, maintenance windows stayed code, and Jev writes to a queue, never to a machine. Jev is early access from a weeks-old lab, evaluated so far on the vendor's own workflow evals against reference models the vendor picked. The name is already being borrowed: an unrelated company shipped an open-weights model called JEV-27B this week, which has nothing to do with TypeSafe. Read carefully before you paste a benchmark.

The planner kept the morning. What changed is that the whiteboard now has defaults, and his queue holds the cases worth a human.

Would I reach for it again?#

Yes, for decisions that fire all day and fit inside a typed question, with a threshold underneath and a log behind. The outreach engine applies the same discipline to outbound: every send and every reply transition lands in a queryable ledger. Not for anything that needs explaining. Jev returns probabilities rather than reasons, and an audit wants reasons attached by the system around it. The chat model still earns its place one layer up, writing the shift report nobody wants to write. The routing layer just stopped pretending that its job needed words.