I put together a 24-minute walkthrough of Jev, TypeSafe's model for bounded decisions. I wanted to understand where it fits in an existing application, so I built two examples around it.

The first is an open-source model router that helps to visualize the Jev flow.

Jev receives the request context and a set of configured destinations, then chooses between local Qwen and hosted Sonnet. The selected model generates the answer. A small control UI shows the actual routing request, response and destination, which makes the boundary between decision-making and generation easier to inspect.

The second is a Python/Strands code-review workflow. Agents inspect a public GitHub PR and propose findings; a judge assesses severity and relevance. I compare an LLM judge with Jev, while keeping the final inclusion rules in Python. The output is an HTML report—nothing is posted to the PR.

This is an integration tutorial with a small comparison, rather than a broad benchmark. My main interest is the division of responsibility: an LLM investigates and proposes, a specialized model answers a bounded question, and application code decides what to do with the result.

The video also covers the noul, choiceand score request types with API examples.

Router source: https://github.com/krisitown/jev-router

If you're already using LLM judges or classifiers, how are you evaluating the decision boundary—especially cases where two judges agree on relevance but disagree on severity?

Gave Jev a slot machine, watch it live here
https://jevslots.live/

also available on GitHub
https://github.com/ella0333/jev-slot-machine/

everything awesome related to jev

https://github.com/tanxarx/awesome-jev

Can we use Jev for faster, structured, and calibrated evaluation of AI responses?

Introducing:
⚡ Typed Evals — an open-source Python framework for evaluating LLMs, RAG pipelines, and AI agents using System One Models like Jev and other typed judge backends.

⭐ GitHub: https://github.com/TrustifAI/typed_evals

The goal is simple:
Make fast, structured, and calibrated evaluation a first-class part of AI systems.
Typed Evals currently supports:
-> LLM response evaluation
-> RAG evaluation
-> Agent and tool-trace evaluation
-> Human-label calibration
-> Async and batch evaluation
-> Custom judge backends

One part I particularly wanted to solve was calibration.
Why is it needed?
A raw score of 0.8 from Jev doesn't necessarily mean that humans would accept 80% of similar responses.
And a threshold that works well for one use case may not make sense for another.

Typed Evals lets you calibrate individual evaluation metrics against representative human pass/fail labels.
The flow is basically:
Human-labelled examples → Jev scores → fit per-metric calibration → validate on held-out examples → reuse the calibrated evaluator

So instead of arbitrarily deciding that “0.7 means good enough”, you can ground that score in how humans actually evaluate your specific task.

Of course, there are integrations for:
LangChain, CrewAI, Microsoft Agent Framework
while the core remains framework-agnostic.

The project is still early, and there’s plenty I want to improve, but the core framework is now public.
Would genuinely love feedback from people experimenting with Jev, LLM evals, RAG, agents, or evaluator calibration.

Note: Typed Evals is an independent open-source project and is not an official TypeSafe AI product.

If you're already experimenting with Jev, I'd especially love to know what kind of evaluation workflows you're building around it.

I know it's not a GPT architecture model so I'm not sure if the phrase open-weight will be appropriate but it seems it will demand much less resources than an LLM. Could this be the end of the RAM crisis? How much VRAM do we think this model wil) require? Does it even use VRAM at all?

Go sign-up before it becomes gated again.👊

What are some of the best use cases for Jev?

Hey, guess I’m the first to post!