# Jev Jev is a [[Decision Models (DMs)|decision model]] by [[TypeSafe AI]], launched on 15 September 2026 as the first commercial [[System One Models|System One model]]. You give it some state (a string, a list of strings, or name/value pairs) plus typed questions, and it returns numbers: a choice among options, a yes/no probability or a score, each with a calibrated confidence. It never writes a single word of text. Why should you care? Because a HUGE part of what we currently ask [[Large Language Models (LLMs)]] to do is exactly that: pick a category, decide whether something matches, rank candidates, check whether an agent is stuck. We've been paying for a model to write JSON, then parsing it, then retrying when it breaks. Jev removes that whole failure class, and it does it one to two orders of magnitude faster and cheaper. ## How it works (from the outside) - **Three question types.** *Choice* (a probability distribution over the options you provide, up to 255), *Noul* (a yes/no probability between 0 and 1) and *Score* (the expected level on a rubric you describe). [[Diogo Almeida]] maps them to programming constructs: choice is a `switch`, noul is an `if`, score is sorting or thresholding. Details and gotchas in [[System One Primitives]] - **Where the names come from.** The API and docs say **Noul**, while Almeida says "Noulli" on the Latent Space podcast and explains that it comes from **Bernoulli** (a Bernoulli probability: a yes/no outcome with probability p). The docs themselves never explain it. *Jev* comes from William Stanley Jevons and the [[Jevons Paradox]], and *System One* from [[Daniel Kahneman]] (see [[System 1 and System 2 Thinking]]) - **State in, typed decision out.** The state is encoded once; every question reads that shared state in parallel. Ask ten questions about one support ticket and you pay for the ticket once - **Calibration by training.** TypeSafe trains with *[[Reinforcement Learning for Calibrated Decisions (RLCD)|Reinforcement Learning for Calibrated Decisions]]* (RLCD) rather than [[Reinforcement Learning From Human Feedback (RLHF)|RLHF]]. The goal is "epistemically honest" probabilities: when Jev says 80%, it should be right about 80% of the time - **No text generation.** The output is typed by construction, so type errors are impossible (no retries, no schema validator) - **Confidence is a rescaled probability.** The docs describe confidence as "a statistic computed from the probability distribution". For N options it works out to (N × top probability − 1) / (N − 1), as bernoulli.app verified. So it's a rescaled top probability, not a second opinion. Don't count a high confidence as extra evidence on top of the probability TypeSafe hasn't published the architecture. Archer Hume reverse-engineered it with ~10,000 API calls and concluded it's most likely a causal transformer backbone (probably sparse mixture-of-experts, given ~160 ms for 30k tokens) with a readout layer instead of a language head, a shared state prefix, isolated question branches, and options read *jointly* (adding an irrelevant option shifts the odds between the others). He measured an expected calibration error of 0.031 on 1,200 MMLU items. These are behavioral inferences, not confirmations (he says so himself). ## How it was trained TypeSafe hasn't published a paper, the reward function or the base model, so this section is what Almeida said publicly plus what the docs state. - **RLCD names a target.** On Latent Space, Almeida frames RLHF, RLVR and RLCD as three different *tasks* for [[AI Post-Training|post-training]], not three optimizers: "The thing that I'm calling RLHF is the task of instruction following. It's not about the PPO." RLHF optimizes for what people prefer, [[Reinforcement Learning with Verifiable Rewards (RLVR)|RLVR]] for answers a program can check (math, code), and RLCD for decisions whose probabilities match reality ([[AI Model Calibration]]). The exact recipe is "novel, unpublished". Outsiders guess it uses [[Proper Scoring Rules]] such as the Brier or log score on the typed output distribution; Di Zhang goes further and proposes a Plackett-Luce ranking objective plus a Brier calibration term. Both are **speculative** - **Why not just RLHF?** Almeida co-authored [[InstructGPT]], and his argument is that preference training damages exactly what software needs: it rewards [[AI Sycophancy|sycophancy]] and confident-sounding answers, and causes "mode dropping" ([[Mode Collapse]]): "GANs mode drop. They, like, drop the minority classes and just do the really common ones." For a classifier, losing rare classes is fatal. He also says calibration is "total poison" for probability distributions over free text, which is one reason the outputs are typed - **100% synthetic data.** The training data is entirely synthetic and built per task shape. User data is deliberately left out to avoid overfitting to "the present day", and customer data is never used for training - **A data lab, not a model lab.** "Data matters way more than compute." "Data is so unbelievably complicated, and that is what gets nines." The data team hunts down jaggedness and fixes it "surgically" ("Our cognitive core is, like, way less jagged than anyone else's"), and the company says it's hiring "infinite data people" - **One set of weights for everyone.** No fine-tuning, no LoRA. You adapt Jev to your domain only through the request: your content in the state, your rules in the questions and criteria, and decomposition in code ([[Atomic Question Decomposition]]) - **Serving.** Almeida admits to "absolutely disgusting things" to reach the intelligence-per-dollar frontier, without details. Archer Hume's reverse-engineering (above) is the best public picture ## Numbers - **Price:** $0.042 per million input tokens; output is free. That's cheaper than GPT-5 Nano's input price - **Latency:** 70 to 500 ms end-to-end for a batch of questions - **TypeSafe's claims:** 20 to 200x faster and 40 to 400x cheaper than frontier LLMs at equivalent quality on their workflows. Read those as ceilings for a single decision call, not as what a whole workflow gains - **Access:** waitlist on typesafe.ai, or no waitlist through [[Vercel AI Gateway]] (`typesafe-ai/jev`), [[Cloudflare Workers AI]] (`typesafe/jev`) and [[OpenRouter]] (`typesafe/jev-1.13`). Listed limits: 250,000 tokens/s and 1,200 requests/min. Text only - **Adoption:** [[Vercel]] says Jev was adopted faster than any model in AI Gateway history: about 13% of teams on day one, 2x the GPT-5.6 family and 6x Fable 5.1 - **[[Every (Company)|Every]]'s testing:** 25x faster and 600x cheaper than a [[Claude Fable 5.1]]-level judge ([[Dan Shipper]]) - **Real use:** Matthew Berman categorized 724 ads across 37 brands in 40 seconds for 9 cents; one [[Hacker News]] commenter sent over 1,000 requests for about $0.01 ## What people build with it Nate B. Jones grouped the early builds into four patterns, and I find that list more useful than any single demo: 1. **Add interpretation to an existing workflow.** 70,000 insurance support tickets categorized, with new tickets flowing through the same pipeline 2. **Ask new questions of old data.** Eight questions applied to 3,282 social posts (topic, hook, tone, performance) 3. **Decide where deeper reasoning is worth spending.** Jev flags what needs attention, then an LLM handles the few cases that matter. One developer halved his agent's costs by letting Jev pick the reasoning effort per step 4. **Give small elements their own judgment.** A prose linter asking ten yes/no questions per paragraph. At this price, it's actually worth doing Other examples: spam detection, search reranking (score the top BM25 hits), routing, guardrails, real-time classification while the user types, browser control with [[Playwright]], chess and Snake bots, and [[fast-jev-compaction]], which uses Jev to compact [[Claude Code]] sessions in about a second. The madewithjev.com directory collects builds with the numbers their authors reported (not verified). A few that stuck with me: Tocsin grouped 22.8 million log lines into patterns and asked one question each, in about 6 minutes for $0.64. Someone ran fourteen yes/no questions over 100,000 viral posts in 20.4 seconds for $0.67. [[Every (Company)|Every]] had Jev make 1,709 editorial judgments over 37 documents for less than a cent, and it caught 6 of 7 planted defects. ## Jev inside agents The builds that interest me most aren't the batch jobs. They're the ones that put Jev at the branch points of an agent, where an LLM used to make every small call. - **[[LangGraph]] (LangChain).** The graph owns the flow; Jev answers the bounded questions at each node. Their e-discovery example asks three questions per page in one request (responsive? contains personal data? possibly privileged?) and routes accordingly: set aside, redact with an LLM, or pause for an attorney. Jev was 5 to 6x faster than Sonnet on the classification step. They also found that Jev-as-a-judge scores "barely moved across 100 repeated runs", far less than any LLM judge they tested - **Stagehand (Browserbase).** `act()` marks the interactive elements on the page, Jev picks the action type and the element, and anything under 0.7 confidence falls back to an LLM. Median latency went from 1.97 s to 0.46 s (about 4.3x) - **[[OpenClaw]].** Decision models are now an opt-in, separately configured model type. Plugins call `api.runtime.decisions.evaluate`, agents get a provider-neutral `decision_evaluate` tool, and the adapter works with hosted Jev or a local server like [[Kev]]. Josh Lehman's lesson from his first attempt is worth remembering: giving the agent a Jev tool left him with "a slow language model thinking about when to call a fast API". The real gain comes from calling Jev in application code. Ideas on the table: should the agent reply in a group chat at all, which tool and skill definitions the main model needs to see, which messages survive compaction, and which model to use for a task - **[[Pi Mono|Pi]].** Pi 1.0 ships Jev as a built-in "classifier model": through TypeSafe directly (`jev-latest`), [[OpenRouter]] (`typesafe/jev-1.13`) or [[Cloudflare Workers AI]] (`typesafe/jev`, next to Cloudflare's own [[Cloudflare Clef|Clef]] and Clef Flash). Classifier models don't show up in `/model`. The agent reaches them from the `codemode` tool (off by default; enable it with `"defaultTools": ["+codemode"]`) by writing a script that calls `models.classify(model, { state, questions })`. Extensions skip the script and call `ctx.modelRegistry.classify()` directly, which is the application-code path Lehman recommends. For a worked example, Elvis Saravia's DAIR.AI tutorial wires Jev (via OpenRouter) into a Pi SDK harness three times: as router, as tool gate and as verifier - **[[Claude Code]] model routing.** jev-model-router (a claude-code-templates mod built on function hooks) asks Jev before every turn how mechanical, reasoning-heavy and risky the task is. It moves up to a stronger model on weak evidence and only down to a cheaper one when it's confident. If the call fails, the request runs untouched - **[[jev-mcp]].** Twelve MCP tools (verify claims, screen fetched pages for prompt injection, rerank, gate a merge...) for any MCP client - **Learning from agent runs.** Asymptote Labs' Beacon records sessions across Claude Code, Codex, Cursor, OpenCode and others. Jev scores each run for evidence, reuse potential and human corrections, and a policy decides which ones become reusable skills. A commenter raised the right concern: a lesson tied to one codebase's quirks can look reusable and "poison" unrelated agents if the promotion policy is loose The common thread is what Jaya Gupta calls "cheap by default, frontier on exception": each step goes to the cheapest model that can handle it, and the LLM only gets the cases the decision model isn't sure about. That's [[Confidence-Gated Routing]] and [[AI Model Cascades]] put into practice. ## Limitations and criticism - **Black box.** An LLM can explain why it flagged something as spam; Jev gives you a number. [[Simon Willison]] worries about hidden bias in sensitive decisions (e.g., hiring). His test rating Bay Area cities put Cupertino at the top and East Palo Alto at the bottom. His advice: evals and structured experiments matter even more here - **Known weak spots.** The Jev 1.13 docs admit it struggles with numbers, dates and adversarial content. It also fails when the needed information isn't in the state, when the answer space is unbounded, or when the question needs real multi-step reasoning - **Closed and opaque.** API only, waitlist, no paper, no weights, and the terms forbid public benchmarking. Some HN commenters called that "Oracle-style"; others argued there's no benchmark "because it's not very intelligent at all". One commenter claims the no-benchmark clause was meant for the limited preview and stayed in the launch terms by accident (unverified) - **Demos flatter it.** Skeptics point out that the Doom demo came with no state encoding, prompts or control loop. If the state already says "you're pointing at the cacodemon", the hard part was done before Jev was asked anything. I'd judge every demo by the state that gets fed in - **Is it even new?** Plenty of people pointed out that classifiers, logit reading and prefix caching all existed before. The creator of [[Laya]] published a very similar non-autoregressive decision model in March 2025. Almeida's answer is that the novelty is the combination and the training, not any single piece - **"Jev in 25 lines of Python."** A (self-declared parody) post read option logprobs from a local LLM to mimic the interface, and reached 691 points on HN. The comments are the useful part, because they list what breaks: check that the options cover 95-99% of the probability mass (otherwise the model wanted to say something else), permute the option order and average (LLMs favor "A" when unsure), and put the options BEFORE the content (with causal attention, the model then knows what to look for; in one test the right label went from 52% to 93%). Even then, the probabilities aren't calibrated. That's precisely the gap RLCD claims to fill - **Calibration drift.** Probabilities calibrated on one distribution can quietly drift on another. Test on your own data before trusting a threshold ## Known failure modes (Jev 1.13 jaggedness) To their credit, TypeSafe documents where `jev-1.13` breaks (last reviewed 2026-09-17), in the spirit of [[Jagged Intelligence]]. Nine failure modes, each with a workaround: 1. **Literal reading.** It answers the question you wrote, not the one you meant. If you catch yourself explaining what you meant, that explanation is the missing half of the instruction 2. **Math and numbers.** It doesn't count reliably and can't judge whether two hex colors or RGB triples are close. Count in code, or ask one yes/no question per item and sum the answers. Don't interpolate exact magnitudes from a Score 3. **Date and time comparison.** It reads dates as text, not as ordered quantities. Extract the date parts as Choices and compare in code 4. **Indirection.** Double negatives and "a property of a property" cost accuracy. Point at the exact part of the state 5. **Large state full of irrelevant detail.** Accuracy drops as unrelated content grows ([[AI Context Rot]]). Filter first, or use a relevance question to filter 6. **Adversarial content.** The state isn't treated as hostile; injected instructions or text arguing for its own classification can move the answer. Be explicit in the criteria and test edge cases 7. **Contradictory instructions and criteria.** A Noul whose `true` means "no" performs worse. Keep criteria as an extension of the instruction 8. **Common-sense structural invariants.** The same refund question gave 0.22 as a Noul and 0.01 as a yes/no Choice; "refund?" plus "not a refund?" summed to 1.19. Don't port thresholds between forms ([[Relative vs Absolute AI Judgments]]) 9. **Generation.** It isn't trained to produce text. Extract candidates with regex or an LLM and let Jev pick ([[Candidate-Then-Select Extraction]]) ## Independent tests Since the terms of service forbid public benchmarking, the independent evidence is scattered across blog posts. What I found: - **Rajesh Beri (phishing, 2,000 PhishNChips v5.2 emails).** One binary question: Jev **62.6%** vs Claude Haiku 4.5 81.3%. Five atomic questions combined with a logistic regression (fit on 1,000, tested on 1,000): Jev **95.0%** vs Haiku 93.2%, at 12-27x lower cost. But Haiku's best single signal already reached 94.2%. On synthetic support tickets he measured an expected calibration error (ECE) of **0.107** ("4.4x the noise floor"), with Nouls underconfident and Choices and Scores overconfident; on an unknowable task Jev was right 44.7% of the time at a mean probability of 0.74. His verdict: "The 95% is not Jev. It is Jev plus your labelled data plus a regression you maintain" - **Archer Hume (calibration and architecture).** ECE **0.031** on 1,200 MMLU items. 990 of them sat in the 0.9-1.0 bin (predicted 98.7%, observed 96.3%, so slightly overconfident), with larger gaps in the middle bins. 84.6% on MMLU-Pro. Nicely calibrated even when weak: 86.7% right at a mean probability of 0.83 on three-digit multiplication, 32% right at 0.30 on two-step word problems. His tokenizer fingerprinting matched no public tokenizer; the closest was [[Qwen]]'s (348 of 415 probes), which *suggests* a modified public base or distillation (**speculative**, not confirmed) - **Anthony Maio (critique).** The reward, architecture, training and calibration method are all undisclosed. "Cannot hallucinate" only means it can't invent a field you didn't declare; it can still pick the wrong option with high confidence. Distribution shift can "quietly undermine probabilities that were reliable last month". And the point I find most important: "Individually calibrated judgments do not automatically compose into a calibrated workflow once you run them through thresholds, weights, and branches." He sees the real strength as "architectural rather than algorithmic" - **KDnuggets (Abid Ali Awan).** Incremental rather than revolutionary: zero-shot classification and intent detection have existed since 2019-2020. Still, it reports 96.3% on an independent fact-checking test of 108 claims (Gemini 3.1 Flash Lite 94.4%, Claude Haiku 4.5 93.5%) and routing decisions in 145-271 ms - **The Register.** Calls the "hallucination-free" framing unfair (there's no natural language to hallucinate in), doubts that the Jevons analogy holds for tokens, and covers the demo of Jev playing Doom from structured game state: 0.114 s per decision vs 8.566 s for GPT-5.6 Terra - **Turing Post** noticed that TypeSafe's own adapter returns different confidence values than the hosted API, and that there's not enough detail to separate what comes from RLCD, the architecture, the data or the serving - **JevBench (Florian Standhartinger).** An MIT-licensed benchmark of 534 English decisions, scored on chance-corrected accuracy, calibration, speed and cost. Leaderboard at the time: Jev 74.4, [[SemIf]] 73.1, djev 73.0, Winnow-12B 71.2, reflex 4B 70.3. The author says ~1-point gaps can be noise. HN split in two: some read it as proof that Jev is "Qwen, fine-tuned a little", others replied that it only tests text classification and not what Jev was probably trained for. The slop-detector demo built on top didn't help its case: a random keyboard mash came out 86% "AI-written" - **Other community evals.** The awesome-jev list tracks more than a dozen (phishing, spam, prompt injection, calibration on Banking77 and CLINC150, reranking). One result worth remembering: on 9,831 labelled pairs, Jev alone didn't beat embeddings for search reranking; combining both did - **TypeSafe's own evals** use model-generated reference answers (the average of GPT-6 Astra and Fable 5.1). On four workflows, Jev reached 67.8% agreement at $0.0004 and 0.4 s per case, vs 67.9% for GPT Terra at $0.0304 and 10.1 s (per Maio's summary). Same quality, a fraction of the cost, but measured against a model-made ground truth The common thread among critics: no paper, no reliability diagram, no ablation. My reading: the calibration is real but distribution-dependent (0.031 on MMLU, 0.107 on tickets), and most of the impressive results come from decomposition plus your own glue code. ## Open alternatives Within days, the open-source community rebuilt the *interface* (not RLCD, not the training data): [[SemIf]] (formerly OpenJev), [[Kev]] by Jared Palmer, [[Jevlike]], and [[Laya]]. There's also mini-jev, a parallel constrained decoding engine for Apple Silicon, and a vLLM pull request turning DiffusionGemma into a multiple-choice machine. More arrived in the following two weeks: - **[[sys1]]**: a Rust server that serves open models like Laya behind a TypeSafe-compatible API, so code written for Jev can point at a local endpoint - **Tev1** (Together AI): an open Jev-style classifier (0.8B, ~50 ms). Their guide fine-tunes one on Qwen3.5 4B with ~38,000 sampled questions in about 25 minutes, for roughly $17 - **eve-rlcd** (Anthony Maio): a 0.6B model trained only on right/wrong feedback, with a reward of "outcome minus stated probability", plus an RLVR ablation. Open weights, and explicitly not a reproduction of TypeSafe's method - **Verdict**: a 118M bi-encoder on the same wire format that runs on CPU or in the browser; its own README says it loses to Laya Three lists track it all: [awesome-jev](https://github.com/Amal-David/awesome-jev), [kraayenjon's awesome-jev](https://github.com/kraayenjon/awesome-jev) (with a "builds with real numbers" table backed by madewithjev.com), and [awesome-jev-projects](https://github.com/logicrw/awesome-jev-projects), a searchable radar of 850+ projects. A survey counted 2,170 public GitHub projects one week after launch. ## My take I think Jev matters less as a model than as a new building block. We had code (deterministic, cheap) and LLMs (flexible, slow, expensive). Jev sits in between: a semantic `if` statement you can afford to call thousands of times. That changes which ideas are worth building. Remember the Jevons paradox? TypeSafe named the model after William Stanley Jevons on purpose (i.e., make judgment cheap enough and we'll use far more of it, not less). The agent integrations convinced me more than any benchmark. OpenClaw, LangGraph and Stagehand all landed on the same design within two weeks: code owns the flow, Jev makes the bounded calls, and an LLM only gets the uncertain cases. When independent teams converge like that, the pattern will probably outlive this particular model. What I'm cautious about is the opacity. I'd use it for triage, routing and filtering where a wrong call is cheap and can be caught downstream, and keep an LLM (or a human) in the loop for anything consequential. And I'd really like to see the open models close the gap, because a decision layer this central shouldn't live behind a single closed API. ## References - [Introducing System One Models & Jev (TypeSafe AI)](https://typesafe.ai/blog/introducing-system-one-models-and-jev) - [Jev notes (Simon Willison)](https://simonwillison.net/2026/Sep/21/jev/) - [Jev: System One models for Prod, not God, with Diogo Almeida (Latent Space)](https://www.latent.space/p/jev) - [Jev's Architecture Unmasked (Archer Hume)](https://archerhume.com/posts/jevs-architecture-unmasked/) - [How to use Jev AI (Linas Beliūnas)](https://linas.substack.com/p/how-to-use-jev-ai) - [Open-source Jev alternatives (Apidog)](https://apidog.com/blog/openjev-open-source-jev-alternatives/) - [awesome-jev](https://github.com/Amal-David/awesome-jev) - [Jev is HERE. How to use it (Greg Isenberg with Ryan Vogel, YouTube)](https://www.youtube.com/watch?v=4mTLpuQpB80): input plus output schema, a probability per choice in ~200 ms; demo sorts 1,700 emails for $0.18; lead scoring, support routing, video clipping, browser control - HN: [OpenJev](https://news.ycombinator.com/item?id=49752041), [Jev: a new shape of LLM](https://news.ycombinator.com/item?id=49796843), [awesome-jev](https://news.ycombinator.com/item?id=49802160) - X: [Simon Willison](https://x.com/simonw/status/2102175146740232238), [Nate B. Jones' build patterns](https://x.com/natebjones/status/2101421649774236145), [Elvis Saravia's beginner's guide](https://x.com/omarsar0/status/2101774405521301681), [Alex Volkov on fast-jev-compaction](https://x.com/altryne/status/2100739055923425589), [Jack Cheng](https://x.com/jackcheng/status/2100729670991802386), [Dan Shipper](https://x.com/danshipper/status/2099947471518474522), [real-time prompt classification](https://x.com/dWeaths/status/2102415625301717065) - LinkedIn: [Antonio Gulli on the open reimplementations](https://www.linkedin.com/posts/searchguy_two-years-in-stealth-to-build-a-new-ai-paradigm-share-7508035614655635456-x10G), [Clem Delangue on Laya trending on Hugging Face](https://www.linkedin.com/posts/clementdelangue_the-number-one-trending-model-on-hf-is-an-share-7507906261116542977-NcNP) - [Jev 1.13 jaggedness (TypeSafe docs)](https://docs.typesafe.ai/model-jaggedness/jev-1.13) - [AI primer (TypeSafe docs)](https://docs.typesafe.ai/introduction/machine-learning-primer) - [TypeSafe Jev: typed decision model, calibration, decomposition (Rajesh Beri)](https://www.beri.net/article/typesafe-jev-typed-decision-model-calibration-decomposition-shadow-eval) - [Jev: the language model that won't talk (Anthony Maio)](https://anthonymaio.substack.com/p/jev-the-language-model-that-wont) - [What everyone is getting wrong about TypeSafe AI's Jev (KDnuggets)](https://www.kdnuggets.com/what-everyone-is-getting-wrong-about-typesafe-ais-jev) - [TypeSafe AI debuts model for machines that plays Doom (The Register)](https://www.theregister.com/ai-and-ml/2026/09/16/typesafe-ai-debuts-model-for-machines-that-plays-doom/5296711) - [What is Jev and RLCD (Turing Post)](https://www.turingpost.com/p/what-is-jev-rlcd) - [What is RLCD, the secret behind Jev? (Di Zhang)](https://di-zhang-llm.github.io/blog/what-is-rlcd-the-secret-behind-jev/) - [Building Prod with Jev and LangGraph (LangChain)](https://www.langchain.com/blog/building-prod-with-jev-and-langgraph) - [Decision models in OpenClaw](https://openclaw.ai/blog/decision-models-in-openclaw) - [Pi 1.0 docs: use classifier models](https://github.com/earendil-works/pi/blob/main/docs/models.md) - [Jev decisions in a Pi SDK harness (Elvis Saravia, DAIR.AI Academy)](https://academy.dair.ai/resources/jev-decisions-in-a-pi-sdk-harness) - [Is Jev confident? (bernoulli.app)](https://bernoulli.app/articles/is-jev-confident) - [JevBench](https://github.com/fstandhartinger/jevbench) - [awesome-jev (kraayenjon)](https://github.com/kraayenjon/awesome-jev) and [madewithjev.com](https://madewithjev.com) - [awesome-jev-projects (logicrw)](https://github.com/logicrw/awesome-jev-projects) - [sys1](https://github.com/alvarobartt/sys1) - [jev-mcp](https://github.com/jkudish/jev-mcp) - HN: [Show HN: JevBench](https://news.ycombinator.com/item?id=49800574), [Jev in 25 Lines of Python](https://news.ycombinator.com/item?id=49812769) - X: [OpenClaw on decision models](https://x.com/openclaw/status/2102488199486656862), [Alvaro Cintas on jev-model-router for Claude Code](https://x.com/dr_cintas/status/2102153763083432049), [darkzodchi's Jev setup guide](https://x.com/zodchiii/status/2102377493705740417) - LinkedIn: [Avi Chawla on Beacon by Asymptote Labs](https://www.linkedin.com/posts/avi-chawla_another-insane-jev-use-case-jev-is-making-ugcPost-7507733287805788160-Z-vU) ## Related - [[Decision Models (DMs)]] - [[System One Models]] - [[TypeSafe AI]] - [[SemIf]] - [[Kev]] - [[Jevlike]] - [[Laya]] - [[fast-jev-compaction]] - [[sys1]] - [[jev-mcp]] - [[LangGraph]] - [[OpenClaw]] - [[Confidence-Gated Routing]] - [[AI Model Cascades]] - [[LLM Structured Outputs]] - [[AI Model Selection]] - [[Large Language Models (LLMs)]] - [[System One Primitives]] - [[Reinforcement Learning for Calibrated Decisions (RLCD)]] - [[AI Model Calibration]] - [[Atomic Question Decomposition]] - [[Relative vs Absolute AI Judgments]] - [[Self-Consistency]] - [[Machine Native Intelligence]] - [[Jevons Paradox]] - [[System 1 and System 2 Thinking]] - [[Diogo Almeida]] - [[Jagged Intelligence]] - [[AgentRun]]