home /all posts/ here

Probabilistic decisions with TypeSafe's System One model Jev

September 17, 2026 • 10 minutes read • artificial-intelligence llms

TypeSafe's Jev is a new System One model which makes "fast, structured decisions for software". There are three primitives in Jev:

  1. Choice: You ask the model to pick the best choice from a set based on a state.
  2. Score: You ask the model to score a situation in a range.
  3. Noul: You send the model a yes/no question and ask the probability of a yes.

Jev is a general classifier which works on arbitrary input data and responds extremely fast. It does not need to be trained like usual classifiers, making it really powerful.

The three primitives are widespread across agentic tooling and applications and even beyond that in general software engineering. The core idea is to accept the uncertainty with certain kinds of tasks and find the best way through them. Over the last few days, X community has gone crazy over Jev's launch and has been exploring unique use cases.

Why all the hype #

I was genuinely excited when I first tried this model and this was the first time I was actively following this release on X. Something clicked for me, most probably the primitives and the idea of building on top of them in existing software instead of simply re-generating the whole code and looking at systems as black boxes.

The hype around Jev is mostly due to everyone relating to the primitives bit and the UX around it, and because it is extremely fast. Correctness is still an open question for me, but since it's all probabilities, you can implement your own guardrails.

My experiments: tool selection in agents #

I have been experimenting with local LLMs in the browser recently and trying to make a full-featured agent possible in the browser, i.e. the model is loaded locally using WebLLM and it can use various tools from user-configured MCP servers, connected directly in the browser via HTTP SSE or via a stdio bridge proxy.

One of the primary limitations with browser-local LLMs is the model size. There is an initial cost of loading the model which limits the size of the model you could use, and eventually the number of parameters of this model and its functionality. I was experimenting with Qwen 3 8B for this purpose but WebLLM does not support tool call for this model directly so I had to implement some kind of hacky technique myself where I would send a list of tools to the model and ask it to choose the best one. This was indeed slow.

I tried this today with Jev and changed the workflow to do the following:

  1. User sends a message
  2. The agent loop asks Jev two questions:
    1. To select the best tool out of the available ones from configured MCPs
    2. Pick the best option for tool call arguments from a set of possible arguments (parsed with heuristics)
  3. Jev responds extremely quickly with the best match
  4. The agent executes the tool
  5. The response and initial message is then sent to the main model (Qwen3) for response generation

This worked quite well, the responses from Jev are extremely fast and structured. Here's what the Jev client SDK API looks like. It has one state and multiple questions of one of the primitive types.

const criteria: Record<string, string> = {
    [NO_TOOL_CHOICE]:
      "No tool is needed to respond to this message; a plain reply is enough.",
  };
  for (const tool of tools) {
    criteria[tool.name] = tool.description || `Use the "${tool.name}" tool.`;
  }

  const answers = await askJev(`User message: ${userMessage}`, {
    tool: {
      type: "choice",
      instructions:
        "Which tool, if any, should be used to respond to this message?",
      criteria,
    },
  });

The response looks like follows:

{
    "model": "jev-1.13.0",
    "answers": {
        "tool": {
            "type": "choice",
            "choice": "get_me",
            "confidence": 0.91,
            "probabilities": {
                "__none__": 0.08,
                // other probabilities ...
                "get_me": 0.92,
                "push_files": 0,
                // other probabilities ...
            }
        }
    },
    "usage": {
        "input_tokens": 2360,
        "output_tokens": 440
    }
}

Here, Jev returned back with 91% confidence that get_me is the relevant tool here.

What folks are building with Jev #

I have come across multiple use cases for Jev and what I'm seeing is it has opened up a way of modelling problems where determinism can be added when there's some level of uncertainty. Think of all the existing use cases for classification - Jev would be a great tool for these, and more! Here's what people have been building on X.

Harnesses #

Many steps in a harness can be done very well and quickly by Jev. The one I already mentioned was tool selection. Others include model routing, i.e. picking the right models for a task to optimise either performance or cost.

Browser agents and computer use #

One of the problems in interacting with browser UIs via natural language prompts has been the indeterminism while converting the prompt to UI element identifier. Using Jev, this could be converted into a decision problem: given the current DOM tree, which element should be interacted with to perform the next action?

This concept can also be extended for E2E testing and people have shared working examples, especially on mobile where this has been hard before.

Command safety classification in auto-mode #

Classifying whether a command is safe to be run locally by an agent could be handed over to Jev. I am not sure how successful this would be, but seems like a valid use case.

Classifying and routing tickets/issues/forms #

Jev is being used to classify an incoming support request as one of the predefined types. This works great due to the choice primitive and is super fast with Jev.

Higher programming primitives based on Jev #

An interesting take is embedding Jev's primitives into code directly and creating programming syntax which works on uncertainty. Imagine being able to branch based on probabilistic conditions. I had thought of this early when I was exploring LLMs and thinking about how they can be embedded into software, but a classifier works better than general purpose LLMs.

What next #

I recommend you to give Jev a try. These primitives make more sense to me for building software than general purpose LLMs in many use cases currently. See if some of your existing problems are decision-based and try to integrate Jev there. You'll notice a significant difference.

Related posts


Subscribe to get my latest posts by email.

    I won't send you spam. Unsubscribe at any time.

    Built with ConvertKit
    © Mohit Karekar • [email protected] •