Is Jev open source?

Akshay 🚀

@akshay_pachaar

A faster, 100% open-source alternative to Jev. It’s called Laya. Both models solve the same problem. You give them unstructured state plus typed questions. Instead of generating a paragraph, they choose from answers you define and return probabilities your code can act on. But they make those decisions differently. Jev is a closed, hosted API. Its architecture and training are not public, but it works zero-shot and supports up to 255 options. Laya is Apache 2.0 licensed, runs locally, and uses open-weight encoder models. Here is how its pipeline works. → It routes by language first. Plain Python selects the English or multilingual checkpoint before inference. → It creates one sequence for each question. Every possible answer gets a `[MASK]` marker. The question and state provide the context needed to compare those options. → It scores instead of generating. A bidirectional encoder and small decision head assign one score to each option. Softmax turns those scores into a probability distribution. → It batches the questions. They run together in one model call, although every question still carries its own copy of the state. This removes network latency and token-by-token generation. In one independent test, Laya took about 35 milliseconds on a local GPU. Jev took roughly 380 milliseconds over the network. Laya also has no per-call API fee, keeps data on your infrastructure, and can run on older GPUs. But it is not a drop-in replacement for every workload. Jev is a hosted generalist that works well out of the box. Laya is a fast base you need to specialize. Laya makes the most sense when you have a stable answer set and representative training data. Fine-tune it for the task, calibrate its probabilities on held-out examples, and send uncertain decisions to a stronger model or human reviewer. Jev gives you stronger zero-shot decisions. Laya gives you speed, privacy, control, and no per-call fee after you teach it your task. The open-source repository is here: http://github.com/NandhaKishorM/laya If you want to self-host Laya, InstaCloud provides a really nice and easy way to do so. Check this out: https://www.instacloud.com/templates/laya If you're new to decision models, I wrote the full breakdown of how Jev. The article is quoted below.

MD Fazal Mustafa

@the_mdfazal

🚨 A LOCAL 421M MODEL JUST ATE CLOUD JEV ON SPEED Laya is an open-source System 1 decision model that runs on your machine. Laya: 86.5 decisions/sec, P50 ~9ms, score 46 Jev: 3.2 decisions/sec, 317ms API round-trip, score 1 Ships with: — 421M params — ~1GB inference memory — Millisecond local calls, no network — Typed decisions in one forward pass — Apache-2.0 and self-hosted While the cloud waits, local decides.

Geek Lite

@QingQ77

复刻 Jev 的并行决策思路，让 0.6B 小模型一次前向直接输出完整概率分布，不做输出 token 解码。 github.com/TianyuCodings/…

Vincent Wang-Maścianica

@vinnylarouge

I reverse-engineered a jev-like architecture given its type. You can find the repo here to train your own jevlikes: github.com/vinnylarouge/j…

Eugene Cheah - AI builder @ 🇸🇬|🇺🇸

@picocreator

love jev, but upset it - isn't open source? - it lack vision capability? We fixed all of that, introducing SimpleJev.ai A fully open source library which takes any HF model and Jev-ify it, with an API endpoint Now on github, and live in production at @FeatherlessAI

Eric Zhang

@ekzhang1

Inspired by @typesafeai , here is a Jev-compatible public API to play with It runs a comparable open model (Qwen3.6-35B-A3B), and just uses SGLang radix cache to preserve the prefill reuse / really fast parallel systemone generation - 64 tasks in <1s. github.com/ekzhang/openje…

Nick Khami

@skeptrune

you can make any open source model behave like jev with just a bit of inference engineering. it's shockingly easy. to prove it, we built a new endpoint we're calling deepseek-v4.1-flash-jev. see the demo below. here's how it's done: sglang (an inference engine) offers a scoring endpoint in addition to the normal generation one. in scoring mode, given an input & set of possible answers, it forces the model to produce probabilities for each one. example: > input: what is most common letter in abcccde? > possible answers: a, b, c > output: (c, 0.9), (b, 0.0.5), (a, 0.05) getting the above behavior instead of streamed output is as simple as using sglang's /v1/score endpoint instead of /generate. there's just one other trick required. for deepseek, you have to add a closing think tag before the response. this forces a direct answer instead of a reasoning trace. if you want reasoning, you can do that too, but imo that makes things too slow to be worth it. dsv4.1 flash is not as good as jev, but if we had enough spare compute to experiment with this same approach for a larger model then i think the decision quality would be at least as good, if not better. also, somewhat unrelated, i think decision-making models kill all prospecting & sourcing work. i would have absolutely killed to have jev or similar when i was recruiting @mintlify. absolutely incredible.

alex nikolic

@justALEXWORTEGA

Typesafe: pnewed 💨 Jev: liberated 🫡 I trained an MLP on top of qwen 4b and it works literally like JEV huggingface.co/AlexWortega/op…

Anand Prasad

@theanandprasad

you can turn any low-cost open-source LLM into a Jev like fast decision model without training it. Here's how to do it: An LLM doesn't write text directly. At every step it scores every word in its vocabulary for how likely that word is to come next, and then it picks one. Those scores are called logits. Suppose you want to know whether a customer email is angry. The usual way is to ask the model, wait while it writes a paragraph, and then try to pull a yes or no out of the response. The trick is to never let it write anything. Give it the email content and the question, and end your prompt with "Answer:". Your full prompt will look something like this: [ Message: "Third time I've contacted you. Still broken." Is this customer angry? Answer yes or no only. Answer: ] The model reads the prompt once and scores every possible next word. You look at two of those scores. "yes" scores 8.1 "no" scores 5.9 Convert those two scores into probabilities and you get 90% yes and 10% no. (Use softmax function -- google it) Your code then uses that number directly. If it's above 0.8, escalate the ticket. Congrats, you have created your own Jev! Here’s why it works: 1. It's fast. Reading a prompt happens in one parallel pass. Writing is the slow part because the model writes one word at a time. Here the model never writes. 2. It's cheap. Output tokens are the expensive ones, and this produces none. 3. There's nothing to parse. You always get a fixed output, and never a paragraph. 4. You get a confidence level along with the answer. A 0.55 means the case should go to a human or a bigger model. A 0.98 means you can act on it. I tried running the code on llama 3.3 70b (via openrouter) and the accuracy was 21/22 (95%). Cost per query: $0.000013, latency: ~500ms

恒星sun

@vintcessun

如果分类结果最终要喂给业务系统，生成一段 JSON 往往不是最省事的路径。Simple Jev 把开放模型变成结构化决策接口。 https://github.com/featherless-ai/simple-jev 它复用共享上下文的 KV cache，只读取各问题候选标签的下一 token logits，再由服务端组装 choice、score 和真值判断。省掉逐 token 解码与 JSON 解析，多问题场景更有价值；common 目录还把提示契约和评分逻辑抽成可复用层。适合路由、审核、打分，但准确率与校准仍需按任务验证。

生ビール

@wmoto_ai

ローカルTypesafe Jev、できたんやないか？ もうちょい速度は改善余地ありそう

Petru - Tech Driven

@techdrivenpetru

Yes but not with Jev. I used another classifier, locally, just as fast, just as good. Example: setup a "server" in python that loads the classifier model. Add a hook in Claude that fires on "pre-tool-use" and next time you ask Claude a random question like "how do I lint check a project?" and it tries to freelance and read your entire repo only to intoxicate itself and pollute its context, the classifier will slap its hand, say "no sir, you answer from knowledge" and deny the tool call. I tested this yesterday with success, but need to refine it as it misfires. Basically I was able to identify general queries, instances where I would ask something and Claude would rush ahead and run pip install without me asking or just write code instead of answering. A classifier is hypercheap compared to a regular LLM and would catch all of these. The model I used was DeBERT large. It's still stupid fast, I tested it on an Apple with M1 (regular) and you don't feel it running.

Simplifying AI

@simplifyinAI

so we already have an open source alternative to jev... and it's 6-7x faster?! it's a typed-decision classification system: no chat, no generated text, just fast yes/no, scoring, or choice answers. > runs in under 1gb of memory > free on hugging face > runs on a laptop, or even a phone there's a real demo where it plays snake live, making a fresh decision every single move. two honest limits, straight from the project itself: > only 512-1,024 token context, some cases won't fit > weaker generalization than jev out of the box