Lately, I have been working on a really simple case. I had an orchestrator that needed to look at a request and make a basic routing decision. Naturally, I threw a standard LLM at it.
We all know what happens next. Depending on the model, especially if it uses internal "thinking" or reasoning steps, you wait. You also pay for every input token, and you pay even more for the output tokens. If you use something like Claude 3.5 Sonnet, that is roughly $5 per million tokens just for the output.
Generative LLMs are built to generate text. But often, we just need a decision.
In this article, I will show you how to solve this cost and latency problem using Jev, a new System One model by TypeSafe released on September 16, 2026. I will also explain how we can bring it into our MuleSoft architectures today.
What is a System One Model?#
Jev is not a traditional LLM. It does not generate open-ended text. Instead, TypeSafe calls it a System One model.
System One models are a class of AI models built to make fast, structured decisions that software can use directly. A System One model evaluates a state and returns typed answers and probabilities.
— TypeSafe
TypeSafe reports that Jev is up to 200x faster and 400x cheaper than comparable LLMs for classification tasks.
Instead of sending a chat prompt, you send Jev a state (your context) and an instruction. It currently supports three specific operations:
| Operation | What it does | Returns |
|---|---|---|
| Choice | Pick from a set of options | A probability for each option and an overall confidence score |
| Score | Rate an input against ordered levels (e.g., low, medium, high) | A continuous score and a confidence value |
| Noul | Answer a yes-or-no question | The probability that a statement is true |
The Cost and the Payload#
You can try this right now on the OpenRouter playground. The pricing is striking. It costs $0.042 per 1 million tokens. That is almost negligible.
When you make a request, you get a clean, structured JSON response. Look at this example for a noul (true/false) operation evaluating if a prompt is safe to run:
{
"id": "gen-dec-1790336577-L3lMplz3pVI33zYN899A",
"model": "typesafe/jev-1.13-20260917",
"provider": "TypeSafe",
"answers": {
"safe_to_run": {
"type": "noul",
"noul": 0.05
}
},
"usage": {
"input_tokens": 384,
"output_tokens": 22,
"cost": 0.000016128
}
}
The cost for this single decision? $0.0000161.
Because Jev evaluates every question in parallel, you can ask multiple questions about the same state in a single request. It barely changes the response time and only costs a few extra, cheap tokens.
Bringing Jev to MuleSoft#
Looking at this, I think that MuleSoft should provide official support for this out of the box, rather than forcing us to build custom integrations.
However, if you want to use it right now with MuleSoft and your AI orchestrators, it is rather straightforward to do. You can build a Mule application that wraps the Jev API and exposes it as an MCP (Model Context Protocol) tool.
Your main LLM agent can then call this tool whenever it needs to classify something. This simplifies the orchestrator's job immensely.
Typical use cases in an integration flow include:
- Model routing: Deciding which tool or downstream API to select based on the incoming request.
- Lead qualification: Instantly scoring an incoming payload (Low, Medium, High).
- Guardrails: Checking if an action is safe before executing a sensitive Mule flow.
Use model-routing middleware. Let Jev assess the incoming request and choose the right tool or model for the job. It is fast and cheap for simple lookups, and leaves the more capable (and expensive) LLMs for when complex reasoning is actually required.
The Verdict#
I rate this approach highly. It is not about choosing between an LLM or Jev. It is an effective combination of both.
You should use an LLM everywhere you need open-ended reasoning and generative text. You should use Jev everywhere you need a fast decision with a probabilistic aspect.
What is your take on this? Are you going to try System One models in your next architecture? Let me know in the comments below. Cheers!
Key Takeaways
- LLMs are expensive for decisions. Paying for generative output tokens just to get a "yes" or "no" drains budgets and adds latency.
- Jev is built for structure. It returns typed answers (Choice, Score, Noul) and probabilities, not chat text.
- The cost is negligible. At $0.042 per 1M tokens, it is up to 400x cheaper than comparable LLMs.
- Expose it as an MCP tool. Until official support arrives, wrap Jev in a Mule application so your agents can call it for fast routing and classification.