A gist published over the weekend shows Laya, an open implementation of the JEV architecture, running fully offline on an M4 Mac through Apple's CoreML at roughly 45 decisions per second. The unit is decisions, not tokens, because JEV models do not generate prose at all. They make bounded calls inside a loop: the classify, route and gate work that a lot of production stacks currently bill to a frontier model at prose prices. The Rundown covered the original TypeSafe release last week, and the detail it led with was that Diogo Almeida, who worked on the research behind ChatGPT, had built a model that cannot produce text by design.
Read conventionally, that gist is a benchmark story. Small model, consumer hardware, fast enough to sit in a hot loop, so the question becomes whether it beats what you are paying for now on the paths where the answer is a label rather than a paragraph. That reading is available and it holds up fine.
The other thing on r/LocalLLaMA the same day was an active thread asking what JEV is and what it is used for, sitting a few slots away from a post by someone who had already built their own. Working artifacts and an open question about purpose, on the same board, on the same day. The distance between those two is a lens, and it shows things the benchmark reading cannot.
Call it the naming lag. Every general-purpose technique goes through a stretch where the artifacts work and the vocabulary for them does not exist yet. Most people read that stretch as immaturity and wait for it to resolve. It is a phase with its own properties, it is short, and the decisions made inside it tend to be the ones that stick. Two of those properties matter. Adoption during the lag is cheap, because there is no consensus to pay a premium against. And the explanation that eventually arrives is usually written by someone with a stake in what it says.
In 2004 I was watching Gmail and then Google Suggest do things inside a browser that the trade press had no word for, and the underlying call, XMLHttpRequest, had shipped in Internet Explorer 5 back in 1999. Jesse James Garrett published the essay that named Ajax in February 2005, the same month Google Maps launched. By the time the word existed, the pattern had been in production for years, and the choices about how it actually worked had already been made in shipped code by people who could not yet say what they were doing.
The longer version of this I watched play out between 1998 and 2001. The enterprise line on open source then was that no serious company runs its business on software written by volunteers with no vendor to sue. Apache had already become the majority web server. Linux was eating the datacenter from the edges, one departmental file server at a time. The deployments were real and growing; what did not exist was language that let anyone defend them in a procurement meeting. Red Hat's IPO in August 1999 supplied it, selling support contracts around a free core, which translated "volunteers" into "vendor" and gave the people already running Linux something they could write on a form.
The tell that the public dismissal was defensive rather than analytical came from inside Microsoft. The Halloween documents, which leaked in 1998, took the threat completely seriously while the public posture still called the whole thing unviable. During a naming lag the public account and the private assessment come apart, and the private one is the accurate one. An incumbent calling something a toy while quietly building a response to it is telling you which of the two readings to trust.
Applied to this week, the frame says the defaults are being set right now by whoever ships during the gap. Open drop-ins already exist: von's 395M model, the RLCD-trained horizontal model, and now a CoreML build that runs on a laptop. Each of those hardens something. What an API call looks like. What counts as one decision, and therefore what 45 per second means. What an eval harness for a model with no readable output would even measure. Almeida named the architecture and framed it as "system one," but that framing does not bind you. If you are one of the people shipping implementations this week, you already have working weights and no vendor roadmap to follow, which means the choices about what counts as one decision are choices Almeida does not get to make for you.
The frame transfers to something that looks unrelated. Simon Willison quoted an engineer two weeks into a job at a large company where the specs, the code, the tests, the PRDs, the tickets and the resolutions of those tickets are all agent output, and where, in that engineer's summary, nobody knows anything. The usual reading is an agent quality story. The naming lag surfaces a different one: the practice arrived at that company without a word for the artifact it produces. There is no accepted term for a document no person wrote that everyone treats as authoritative. Companies have precise language for provenance everywhere else, a signed-off spec, a code owner, a decision record, and none of it maps cleanly onto this. The missing word is costing that team more than the agent output quality is.
It shows up in measurement too. Someone let an agent loop run about three weeks on a single RTX 3090 with roughly a dozen human messages, building a CUDA inference engine tuned to that card. It produced working kernels and benchmarks and never beat llama.cpp. Three weeks of unattended compute to arrive back at llama.cpp is either a rounding error or the most expensive way anyone has confirmed a widely-held prior this month, and I genuinely can't decide which. Long-horizon telemetry with an honest negative result is rare, and part of why it is rare is that there is no accepted unit for the outcome. The same community is drifting from tokens per second toward cost per completed task, which is vocabulary catching up on one axis while the JEV question opens a new one underneath it.
Naming lags close. They close when someone with a commercial reason supplies the explanation, the way support contracts explained free software to procurement, and the supplier of the explanation gets to shape what the category is for. Decisions per second is already a vendor's unit, and if you adopt it without checking, you have accepted the most conservative available reading of a model class that cannot talk: a throughput improvement on work you were already doing, not a new kind of routing decision you get to define on your own terms. The other candidates to supply the explanation are the people putting CoreML builds on laptops, who have a different interest entirely, and whichever frontier lab eventually decides it needs a story about why the cheap thing is not a substitute.
The thing that breaks first for you, specifically, is the audit path. Every eval harness, every red-team protocol, every safety disclosure of the kind OpenAI published last week and The Rundown walked through assumes a model whose output a person can read and argue with. A JEV-class model's entire output is a choice, made inside a loop, on a laptop, with no text left behind to review. Before you route a live decision to one, decide what you are going to save when it runs: the input, the confidence score, the model version, something that lets you reconstruct why it chose what it chose. Nobody has built that tooling yet, and the thread asking what JEV is for will not get you there. You either build it yourself before the incident, or you find out during one that you can't.