Production AI usually looks like this: stuff context into a prompt, ask a large language model a yes-or-no question, beg it to answer in JSON, then parse whatever comes back and hope.
The punchline is that it actually is incredibly useful to use LLMs for their judgment instead of their writing: is this spam, where does this belong, is this comment actually helpful? LLMs were the best tool for the job, even if they were the wrong tool for the job. The inherent inefficiencies of this idea made scaling an incredibly delicate balancing act of quality, token waste, intelligence and pseudo-determinism.
Then Jev came along, and it seems like the missing piece.
Judgment as a primitive
Jev, from TypeSafe, is a "System One" model. It doesn't generate text. You hand it some state (a comment, a profile, some JSON) and a set of questions, and it returns typed answers with probabilities. There are three shapes: yes/no, pick one from a list, or place it on a scale.
That sounds limiting until you notice how much of our LLM usage fits those three boxes. No parsing, no "respond with only one word." Just a decision your code can branch on, plus a probability that tells it when to act and when to escalate.
How we use it in Forem
In Forem, the open source software that powers DEV, Jev plays two roles.
The first is decision maker. It labels new posts for anti-spam moderation, checks whether a post meets a badge's criteria, picks a highlighting language for unlabeled code blocks, and suggests tags for untagged posts.
The second, my favorite, is traffic cop. Our spam escalation check is a cheap Jev pass that asks a few questions in parallel: is this spam, is it pushing readers to a Telegram or WhatsApp contact, is it promoting something unrelated to this community? It never flags anything itself. It just decides what deserves a closer look from the full check.
Jev is orders of magnitude cheaper than LLMs, and along with lower latency, allows us to inject a layer of intelligence into parts of the system which had to be strictly algorithmic before.
Where this is really headed
These decisions don't need a frontier data center. They need to be fast, consistent, and close to where things happen.
Think about a smart home. Was that a request to turn off the lights, or just a mention of them? Is this motion event worth waking me up for? Those are rigid, reactive, latency-sensitive calls. They should happen locally, without your living room phoning a server farm.
That's why I'm rooting for projects like Laya, an open source take on the idea that you can run yourself. It may not be there yet, but someone will make local judgment models work, and when they do, this whole class of AI moves onto the device.
Practical problem solving
Many production AI use cases wind up as a solution looking for a problem, or simply lack scaled cost-effective usefulness. This tool complements frontier AI intelligence beautifully to maximize the practical roll-out ready usefulness of our systems.
I see the release of Jev as not just a usefulness-first AI innovation, but an articulation for how we should be designing tiered intelligence systems to control for costs and provide algorithmic-like control of our outcomes.