Jev alternatives
Von
The CPU answer, and the strongest open model on the independent board
Quick answer
Von is what to run when there is no GPU: a 395M encoder, ~1.5 GB on disk, under 15 ms per decision on a CPU. It is also the top open model on the independent 49-task benchmark at roughly 0.70–0.72 against Jev’s 0.966 — which is the honest headline of this entire category. Its recorded failure mode is specific: on unfamiliar domains it collapses to a single mode.
Von is a 395M ModernBERT-Large encoder with three decision heads — pick an option, answer yes or no, rate on a scale. It needs no graphics card at all, answers in under 15 ms on a CPU, and takes about 1.5 GB on disk. It also leads the open field on the one benchmark nobody involved in this ecosystem wrote: an independent 49-task classifier suite.
Train a decision model
A small non-autoregressive encoder with decision heads. No text generation at all — the classic classifier shape, rebuilt for natural-language options.
Search aliases
Key specs
- Licence
- Apache-2.0
- Author
- wfzyx
- Backbone
- ModernBERT-Large 395M + three decision heads
- Size
- ~1.5 GB on disk
- Latency
- Under 15 ms per decision on a CPU — no GPU required
- Wire format
- von-sdk on npm for Node.js callers
- Install
- See repository
Von against Jev
The independent 49-task figure is the only number in this whole ecosystem produced by someone with no stake in any of the projects. Read it before any project’s self-reported score.
| Von against Jev | Von | Jev |
|---|---|---|
| Independent 49-task benchmark | ~0.70–0.72 — the best open entrant | 0.966 |
| Clean 20-bucket routing job | ~0.834 on a well-scoped task | Not published for this split |
| Messy 49-task suite | ~0.715 — the accuracy falls off a cliff outside its lane | 0.966 |
| Hardware | CPU, ~1.5 GB, no GPU | Hosted |
| Latency | Under 15 ms locally | Network round trip |
| Recorded failure mode | Collapses to a single mode on unfamiliar domains | See published failure modes |
When Von is the right choice
Choose Von when the deployment constraint is real: an edge box, a laptop, a CPU-only container, or an environment where sending state to a third party is not allowed. It is small enough to be boring, and it is the one open project that earns its place on a benchmark run by an outsider rather than by its own author. Point it at a narrow, well-defined decision — a routing bucket, a yes/no gate — and it is fast and adequate.
When to walk away
Do not use Von for open-ended or unfamiliar domains. Its independently recorded failure mode is collapsing to a single answer when the domain is not the kind it was pointed at, and its own numbers fall from roughly 0.834 on a clean routing job to about 0.715 on a messy 49-task suite. If your inputs are unpredictable, that gap is the whole story, and a cascade up to a stronger model is cheaper than a wrong decision at scale.
Adopting Von in three steps
# Von needs no GPU: 395M params, ~1.5 GB on disk.
# Each decision returns in under 15 ms on a CPU.
git clone https://github.com/wfzyx/von.git && cd von
# install per the README, then serve or call it in-process
# A Node.js caller can use the published SDK:
npm install von-sdk
# import { decide } from 'von-sdk'
# const r = await decide({
# state: 'We were billed twice for March.',
# question: 'Which team should handle this?',
# options: ['billing', 'technical', 'sales'],
# })
# if (r.confidence < 0.85) escalateToHuman(r)Von questions people actually ask
Can Von really replace Jev?
For a narrow, well-defined decision on hardware without a GPU, it can be good enough. As a general replacement, no: the independent 49-task benchmark puts the best open entrant around 0.70–0.72 against Jev’s 0.966. Nobody in this ecosystem is claiming otherwise with clean evidence.
Why is Von rated above Laya when it has far fewer stars?
Because stars measure attention, not accuracy. On the independent 49-task benchmark Von leads the open field while Laya sits at 0.583. Laya has upwards of nineteen thousand stars; Von had a few hundred. That mismatch is the single most useful thing to understand about this category.
What does Von fail at?
Unfamiliar domains. The benchmark records its failure mode as collapsing to a single mode when the input does not resemble what it was pointed at, and the project’s own numbers drop from about 0.834 on a clean 20-bucket routing job to roughly 0.715 on a messy 49-task suite. Always measure your own distribution.
Do I need any special hardware?
No. That is the point. Von is a 395M encoder, about 1.5 GB on disk, and it answers in under 15 ms on a CPU, so it runs on a laptop, an edge device or a CPU-only container — the cheapest deployment story in this comparison.
Sources
- wfzyx/von — repository and claims
- Independent 49-task classifier benchmark (Jev 0.966 vs Von 0.704)
- Best open source Jev alternatives — independent benchmark section
- Run Jev locally: how much accuracy each option trades away
Every comparison number on this page is a third-party published figure or a read of a public repository — not a benchmark we ran. We have not tested TypeSafe Jev itself, and its customer agreement forbids using its outputs to build similar products.