Early experimentation using Jev to rethink harness UX

This video and post cover some internal experiments with a new kind of model, which we used as part of the plumbing of our harness. None of it is in production yet. It’s alpha work.

TL;DR:

  • Running a model like Jev (a classifier with LLM-level intelligence) alongside a regular LLM lets you build kinds of user interaction that we think are where UX is heading. At the very least, they’re an interesting new way for software to behave.
  • elvex is a model-agnostic harness built for teams working together. It’s software for using LLMs, and parts of the platform itself also run on LLMs. Putting Jev into that second part, the platform, is making some pretty magical things possible.
  • The part we’re most excited about: interfaces that rearrange themselves as you type, driven by classification that runs in the background on every keystroke.

What this post covers

This is a write-up of an internal prototype walkthrough. We wired Jev into our agent harness and looked for places where instant classification changes the product experience. It’s written for developers. We’ve tried to keep it readable, but it goes into implementation detail.

What’s covered:

  • What Jev is, and how System One Models differ from autoregressive LLMs
  • How we added Jev to our harness as a tool the agent can call
  • 2,000 expense reports classified in 21 seconds for about five cents
  • Better attention filtering: instead of notifying you about everything, the platform decides when you actually need to hear about something
  • Search reranking and intent routing for search that seems to read your mind
  • Pulling context out of each message at 75 percent lower cost
  • Approvals based on risk instead of blunt auto-approve rules
  • Interfaces that rearrange themselves as you type, driven by background classification of what you’re typing
  • How System 1 and System 2 models work together
  • Why we aren’t shipping it yet: early access, vendor and legal risk

What is Jev?

Jev is the first public model from TypeSafe AI. It came out in early access on Sep 15, 2026. You can read the announcement here.

Most of what we build with LLMs is “System 2” work: slow, deliberate reasoning, one step after another. You send a prompt, the model produces one token at a time, and you wait while it thinks out loud. Jev is made for System 1 work, meaning snap judgments and instant classification. Here’s an input. Which bucket does it go in, and how sure are you?

TypeSafe calls Jev the first of a new class of frontier model, System One Models. The name comes from the distinction in Daniel Kahneman’s Thinking, Fast and Slow between fast, intuitive System 1 thinking and slow, deliberate System 2 reasoning. Jev itself is named after William Stanley Jevons, as a nod to the Jevons paradox: each order of magnitude drop in cost leads to orders of magnitude more use.

According to TypeSafe, three things about it are new:

  1. The architecture is built for automation, not chat. Jev doesn’t generate strings at all. It’s tuned for structured outputs.
  2. A parallel sampler for efficiency. Jev doesn’t produce tokens one after another. It outputs all the probabilities at once in a single forward pass.
  3. A training method called Reinforcement Learning for Calibrated Decisions (RLCD), meant to produce well-calibrated probabilistic decisions.

TypeSafe suggests a way of thinking about it that we found helpful: Jev is like calling a function that has frontier-level intelligence. Unstructured state goes in, typed probabilistic decisions come out.

In practice that gives you three kinds of output:

  • Choice: given up to 255 options, which one it is, with a probability for each. When there are many options, it scores them first and then picks.
  • Score: a number from 0 to 1 for how well an input fits a description.
  • Yes/no: a true or false answer with a confidence, framed as a Bernoulli output.

It can’t generate free text, so you can’t ask it to write a paragraph. Because every output has to fit the schema, TypeSafe says it can’t hallucinate in the sense of returning the wrong type. Schema matching is guaranteed, which means no malformed tool calls hidden three layers deep in a chain of dependencies.

On performance, TypeSafe publishes workflow evals that compare Jev against large models like GPT-6 Astra and Fable 5.1 as the reference answers on production-style workflows. Their headline numbers are 193.6x faster and 444.6x cheaper.

For developers, it comes down to this. You describe a decision boundary in plain language instead of training data, and the model applies it using broad knowledge of the world. If you’ve used an LLM as a judge, the flexibility is similar, with no examples needed, but speed and cost are two orders of magnitude better.

Putting this into a harness as a callable tool

Once it sinks in that noticing things is now cheap, you start seeing places to use it everywhere. We prototyped all the examples below in about a day and a half.

To try it, we added Jev to our agent harness as a tool that can be called from code execution. So an LLM running in our harness knows what Jev is and how to use it, and builds the interaction the user is asking for. The agent writes the classifier definition itself from a plain-language prompt, checks it on a small sample against a slower frontier model, and then runs it across the whole dataset.

The first, simple use case: 2,000 expense reports in 21 seconds

The task: take a CSV of 2,000 expense reports and answer a yes/no policy question for each one. “Is this spend okay?”

The agent did three things:

  1. Wrote the Jev classifier definition from a plain-language prompt (a normal LLM did this part)
  2. Ran it on 20 rows as a spot check and compared the results with a slower frontier reasoning model to confirm they agreed
  3. Ran it across all 2,000 rows

Jev spent about 21 seconds on it in total, and it cost about five cents.

Doing the same experiment with a capable chat model would take orders of magnitude longer and cost well over $100 for the same volume. Even at a few seconds per row, that’s hours instead of seconds.

The interesting part is how the two kinds of model work together. Your System 2 model labels a small sample, you measure how often the two agree, and then the System 1 model does the bulk of the work. It’s the same idea as distillation and evals, except you set up the student model in plain English and there’s no training loop.

So why is this better than the classifiers we already had? Traditional classifiers needed labeled training data and had to be retrained for every new policy. Using LLM prompts as classifiers skipped the training, but each call cost seconds and cents, which rules out high-volume work. Here you get classifiers on demand, with broad knowledge of the world, created by the agent while it runs, and fast enough to sit in the hot path.

You could argue that traditional classifiers are more accurate, and that would have to be checked one use case at a time. But you can’t create them on demand. Jev lets you build classifiers as you need them, which is a completely different way of working.

Smarter attention filtering: instead of notifications for everything, what about a platform that intelligently decides when you need to be notified?

Lots of apps have a fixed “waiting on you” list. A new comment or a meeting gets flagged, and you’re notified about everything. That logic breaks easily: it flags noise and misses messages that need an answer but don’t match any formal trigger.

With Jev you can put an intent classifier on top: is this message actually asking the user something that needs their attention? It’s fast and cheap enough to run on every message after it arrives. In the demo, it caught a message that matched no formal trigger and correctly marked it as needing a reply.

If classifying whether something is finished is cheap, you can hang other behavior off it, such as resolving threads automatically, kicking off retros or suggesting changes to an agent’s instructions.

Search reranking and intent routing

Searching inside an app, for old conversations, agents and data sources, or artifacts, is a big part of everyday work. That’s true of plenty of software that isn’t an agent harness, too.

Jev makes for better search that takes you straight to what you were looking for, with frontier-level intelligence making the call.

Fetch a broad set of candidates with keyword or vector search, have Jev score each one against what the user seems to want, and use that score to rerank.

You can also classify the query before searching at all. Say a user is in a thread full of marketing ad spend reports and starts typing a question. Do they want a thread, a document, or the exact part of the document that answers their question? A classifier can tell, and send them straight to the analysis instead of a list of documents.

That kind of query understanding used to need a lot of training data and dedicated ranking systems. Here we built it from a handful of examples during the demo.

Per message context extraction

elvex updates a user’s context as they use the product. Today an LLM does this. It’s expensive, though worth it, and it’s as imperfect as LLMs are: surprisingly good, but not always right. Sometimes the things it proposes adding to someone’s context aren’t useful.

Jev improves this right away. Every message a user sends can be classified for whether it’s worth remembering: does it contain something that belongs in their personal context?

In the prototype, as soon as a message was sent, a classifier marked it either “yes, useful” or “no, irrelevant.” A normal LLM then took the useful messages and worked out what should be added to the user’s context.

We tested it on real personal usage data, labeling by hand before and after. Compared with the existing LLM extraction pipeline, it cut cost by about 75 percent and produced about 38 percent fewer bad suggestions.

Risk aware approvals for Human-in-the-Loop

Human-in-the-loop (HITL) approvals today are usually blunt: approve everything automatically, approve by action type, or approve nothing. You end up trading safety against interruptions.

Classifiers let you write finer rules: does this action match what the user meant, and does it look safe? In the demo, a request to create a Linear issue went through without asking, because a classifier judged it safe and in line with the user’s intent, even though auto-approval was off for that action type. Coding agents already work this way with their auto-approval systems, where low-risk, high-confidence actions skip review.

On the implementation side, it’s policy as code, where the condition is a plain-language classifier with a threshold.

Interfaces that assemble themselves as you type: Ambient classification while typing powering live UX orchestration

Speed changes what you can build. The most striking demo ran classification inside the input debounce.

While the user typed, the app classified the intent of the unfinished text and suggested what might help most: a related open thread, the right space for the conversation, a data source worth attaching or an integration that wasn’t connected yet.

Think of Google’s autocomplete in the search box. Instead of finishing your sentence, it works out which part of our software you need and puts it in front of you as you go, with no lag you can notice.

For the integration example in the video, the team had already classified every integration by function and use case, then matched what the user was typing against that map. Type email the Q3 recap with no email integration connected, and it suggested connecting one. Type write a Linear ticket with Linear already connected, and it stayed quiet.

Five kinds of suggestion ran in one Jev request with a P50 of 171 milliseconds. At current prices, that’s about 14,000 of those checks per dollar.

Across all our testing, 17.5 million input tokens cost 65 cents. For comparison, 1.7 million output tokens through a strong chat model, covering the same ground, would cost well over $100, and it would be several orders of magnitude slower, so slow that no user would put up with these interactions.

Using two models together is the point

Our biggest lesson is that LLMs and Jev work extremely well together. System 1 keeps proposing and sorting. System 2 makes the final calls and handles the exceptions.

  • Use the autoregressive model for what it does well: hard inference, writing code, drafting instructions, sorting out ambiguity and asking follow-up questions.
  • Use the “System One model” (the classifier) for what it does well: applying that understanding over and over, cheaply and quickly.

Here’s a concrete example from the end of the demo. The user asked for a support agent that answers questions from help center articles and opens a Linear issue when someone reports a bug.

While they typed the description, Jev classified the intent in the background and started building the agent: finding the support site, turning on tools, drafting instructions. When it noticed something was missing, the LLM stepped in to ask a clarifying question and folded the answer into the setup. The classifier built things up quickly, and the LLM did the reasoning when the process got stuck.

What this unlocks

If every message, keystroke, search result and agent action can be classified for intent, risk and relevance for a fraction of a cent, you can build UX that used to cost too much to run: context extraction on every message, integration help before you ask, search that understands intent, approval flows that stay quiet unless the risk is real, and interfaces that rearrange themselves as you type.

We see it as a new building block more than a cheaper model. It pays to think like someone designing classifiers: what would you detect if detection were free, and what would you stop asking the user once you could?

‍

Bring your agent. Bring your team.