Click any tag below to further narrow down your results
Links
Baseten's research lab released two open-source decision models, mammoth-1 (27B) and elephant-1 (9B), built to classify and route inputs by returning probability scores instead of generating text. Both are free to try for a week on Baseten's Model APIs.
- mammoth-1 ranks #1 of 208 decision models on the Jev Decision Index, and elephant-1 is the top 9B model there.
- Decision models return a probability over possible answers rather than writing text, which makes them faster and cheaper than generative LLMs for tasks like ticket routing and spam detection.
- Confidence thresholds let you auto-handle high-certainty cases and escalate uncertain ones to a human.
- Both were fine-tuned from Qwen3.5 on 6.21 million decision-making examples, including training to say "I don't know."
OpenAI has made its Decisions API generally available, a fast, cheap model for picking among options with a confidence score, meant to compete with TypeSafe's Jev. The pitch is that for many workflows, a quick classifier-style model can replace a full LLM.
- OpenAI didn't build a dedicated decision model; it repurposed its ChatGPT Luna model and tuned it for lower latency and cost.
- Speed is the main selling point: response times dropped from 1-3 seconds to roughly 100-180 milliseconds, and Speak cut its action gap from 1.4 seconds to 0.13 seconds.
- Benchmarks don't settle which decision model is best. Jev ranks well on some indices and tops the PacMan-based JevMan test, while OpenAI's model ranks lower, though it may have an edge in image classification.
This is a conversation between Matt Turck and Diogo Almeida about Jev, a system Almeida describes as built to make decisions rather than generate text. The discussion centers on how that shift from output to action could change the way AI gets used.
- Jev is framed as a decision-making system, distinct from text-generation models that produce answers without committing to outcomes.
- Almeida argues that moving from text to decisions changes what evaluation and trust look like, since the output is an action with consequences.
- The episode positions this as more than a feature update, claiming it alters the basic relationship between people and AI tools.
TypeSafe released Jev 1.14.0 with a split approach: stable improvements for production use and experimental "danger zone" features (image support, bounding box type, longer context) for developers willing to accept less reliability. The company is also sharing internal intelligence metrics while acknowledging their limitations.
- Image support is now composable across Jev's JSON interface (state, instructions, criteria), though multimodal performance is weaker than text-only and requires careful prompt decomposition.
- New "box" type returns bounding boxes without type errors, representing the first Jev type designed beyond binary decisions and signaling exploration into broader System One Model capabilities.
- Jev supports longer context lengths than previously enabled in production; developers can opt in via a danger zone flag, but TypeSafe intentionally limits context by default because reliability degrades at scale.
- Internal benchmarking data is being shared for the first time, limited to open-weight models only, with explicit caveats that the methodology will evolve and developers should run their own evals.
A new category of AI models that pick answers instead of generating them launched in September 2026 and immediately spawned dozens of competitors. The article cuts through the noise by laying out practical criteria for choosing which decision model to use in production rather than tracking which specific model is "best."
- Jev launched September 15 and hit massive adoption (13% of Vercel's paid customers integrated it within a day), but within two weeks Amazon, OpenAI, Cloudflare, and others shipped competing models with different tradeoffs.
- DecideBench, an independent benchmark testing 400 multiple-choice decisions across eight task families, shows Jev at 98% accuracy for $32 per million tasks, but smaller open models like Laya are 35-59% accurate and much faster—accuracy-speed tradeoffs matter depending on your use case.
- The real decision criteria are deployment location (hosted vs. self-hosted), input types (text-only vs. image support), latency requirements, cost at your actual volume, and API compatibility for future switching—not which model has the best benchmark score.
MotherDuck's Jev is a decision model that classifies text by picking from predefined answers, running 30x faster than GPT at 1% of frontier model costs. The article walks through five real use cases—grading AI agent logs, analyzing Hacker News sentiment, screening sales calls, and others—with actual SQL queries and datasets you can attach and rerun.
- Jev classifies 100,000 items in 82 seconds at ~1% the cost of frontier models by constraining outputs to a closed list you define, returning typed columns with confidence scores.
- On Hacker News mentions, 89% of pre-2023 "Claude" and "Anthropic" matches were false positives (Claude Shannon, the anthropic principle), but Jev's name-checking reduced false positives to 0.8% post-2023 when the products actually launched.
- The pattern separates facts from judgment: SQL extracts exact counts from logs or data, Jev only answers subjective questions like "was this turn efficient?" or "is this negative?", keeping costs down while maintaining accuracy.
TypeSafe AI's decision model Jev autonomously completed Pokémon Red by reading game memory, evaluating legal moves with game facts, and making every decision—from battle tactics to menu choices—over 37 hours and 16,150 decisions. The entire run cost $1.65 in API tokens, with full source code and setup instructions open on GitHub.
- Jev made every game decision (battles, catching, team swaps, navigation) based on legal options and contextual facts, while the harness only handled emulation and button presses—no cheats or memory writes.
- The project cost $1.65 total at $0.042 per million input tokens, with typical calls around 1,200 tokens and median decision time of 0.4 seconds; the full run consumed ~39.2M input tokens.
- All code is open-source (GPL-2.0) and reproducible locally with your own legally obtained Pokémon Red ROM, Node 20+, and macOS or Linux—no Nintendo assets or ROMs are distributed.
Cloudflare open-sourced two decision models called Clef and Clef-flash that classify inputs into typed, structured outputs with probabilities — useful for routing customer support tickets, identifying phishing domains, or triggering automated agent actions. The models outperform Typesafe's Jev system on speed and benchmarks while supporting images and a 64k context window.
- Clef processes decisions 2x faster than general LLMs (2.2s vs 4.7s in Cloudflare's threat intelligence workflow) because it scores schema choices in parallel rather than generating text token-by-token.
- The models beat Jev on most Jev Decision Index benchmarks and Typesafe's own eval suite, with Clef-flash offering exceptional speed-to-quality tradeoffs; median latency is 209ms for Clef and 38.8ms for Clef-flash.
- Both models are open-sourced on Hugging Face under Apache 2.0, hosted on Workers AI at Cloudflare's edge for low network latency, and fully API-compatible with Jev for easy switching.
Cloudflare's Clef cloned Jev's LLM-based multiple-choice solver in two weeks and beat it 4x on speed with 2x better accuracy using a smarter inference approach. The post argues this shows how hard it is to build defensible software products without proprietary data.
- Clef uses a frozen Qwen model with parallel schema scoring instead of generating text, achieving 4x faster performance and 2x accuracy improvements over Jev on some benchmarks
- Open-sourcing Clef immediately eliminated any competitive advantage Jev had from being first to market
- Without proprietary data or a clear technical moat, launching novel LLM applications offers almost no protection against rapid cloning by better-resourced competitors
Researchers tested an AI system called Jev on 2,029 real phone calls stripped down to pure call structure—no audio or transcripts—and it learned to predict which calls would result in bookings with 94% accuracy by the end, all for $3 in compute costs.
- Jev made 38,012 turn-level forecasts across the calls at 118ms median latency, processing thousands of calls in seconds without any fine-tuning or examples from the company's data.
- The system achieved 0.78 AUC by the halfway point and reached 94% ranking accuracy near the end, learning to separate bookable from non-bookable calls based solely on call structure, timing, and workflow patterns.
- The experiment revealed the AI could extract predictive signal from call metadata alone—turns, tool calls, workflow stages—demonstrating that meaningful patterns exist independent of what's actually said.
Together AI walks through building and deploying a Jev-like classification model on Qwen 3.5 4B for $17. The guide covers dataset selection, fine-tuning, and deploying the model behind an HTTP endpoint so you can query it for tasks like intent detection or sentiment analysis.
- You can fine-tune a working classification model on 38,000 examples for roughly $17 and have it deployed in 25 minutes using Together's platform
- The model accepts JSON-formatted state plus predefined questions and returns structured answers (scores, booleans, or multiple choice), making it practical for e-commerce returns, paper categorization, or sentiment rating
- The entire process is automated through provided scripts—you clone a repo, download datasets, run a training command, and get back a deployed API endpoint ready to integrate
TypeSafe's Jev, a decision model designed for fast binary/graded judgments, outperforms GPT-5.4 nano as an LLM guardrail by 15-18x in speed and 12-14x in cost while catching the same policy violations. The article benchmarks both approaches on a dealership chatbot that screens customer inputs, agent replies, and tool calls against business rules.
- Jev returns typed probability distributions in ~100ms per call versus GPT-5.4 nano's ~1,900ms, and costs $0.042/M tokens versus $0.20-1.25/M, because it's built for structured decisions rather than token-by-token generation.
- Multiple guardrail boundaries (inbound message, draft reply, tool arguments) catch attacks that single-point checks miss—the second attack in the demo never jailbreaks the conversation but fails at the tool-call boundary where an input-only guardrail wouldn't see it.
- Policy rules should be split between model judgment (fuzzy calls like "does this sound like a binding commitment?") and deterministic code (hard rules like "price below floor"), not stuffed into prompts.
Jev is a new AI model that classifies data and answers specific questions 193x faster and 444x cheaper than LLMs, but it's fundamentally different—it's a modernized BERT-style classifier, not a generative model. The author tested it on Croatian text classification and found it matched a fine-tuned model's accuracy while costing pennies and taking minutes.
- Jev achieves 97.1% accuracy on zero-shot binary classification tasks, essentially matching fine-tuned BERT models without requiring retraining
- It costs around 20 cents for 3,000 classifications and completes in about a minute, making it practical for real-world workloads where LLMs are overkill
- The model appears more resistant to prompt injection attacks because instructions are separated from input data during training, unlike LLMs where everything blends together
- Jev's "can't hallucinate" claim means it can't generate outputs outside its specified structure (type-safe), but it can still produce incorrect answers within that structure
New lightweight AI models like Jev and SemIf outperform expensive general-purpose language models on straightforward classification tasks—cutting costs by 76-209x while improving accuracy. These tools skip the expensive token-generation process and instead directly evaluate a handful of predefined options, suggesting a future where production systems use cheap specialized models rather than frontier AI.
- Jev and SemIf reduced classification costs by 76-209x compared to frontier models while jumping accuracy from 47% to 80-82% on email thread categorization
- These models work by running attention once and evaluating candidate answers directly from logits, skipping the expensive autoregressive token generation that general LLMs use
- The author replaced roughly 25% of AI calls in their own code with these specialized deciders, suggesting if-then logic is a ripe target for optimization—and hinting other programming primitives could follow
TypeSafe AI released Jev, a model that takes text input but outputs confidence scores and probability distributions instead of generated text. It's designed for classification tasks like spam detection and ranking, costs $0.042 per million input tokens with free output, and has already spawned open-source recreations and creative experiments.
- Jev returns structured probabilistic outputs (yes/no scores, rankings, category choices) rather than text, making it fast and cheap—you only pay for input tokens, not output.
- The model trades interpretability for simplicity: you get a floating-point score but no explanation of which signals drove the decision, raising serious concerns about hidden bias in high-stakes use cases like hiring.
- The community has already built unconventional projects with it (a chat model, a game player, a left-pad implementation) and created open-weight alternatives like Kev within days of release.
TypeSafe's Jev model works best as a decision layer for SEC filing extraction—you pre-generate candidate values with regex or a small model, then Jev picks the right one and returns confidence scores. This setup costs $0.042 per million input tokens, runs in 70–500 ms, and eliminates the expensive retry loops of pure generative approaches.
- Never ask Jev to invent values; feed it candidates first, then use Choice/Noul/Score primitives to select, verify presence, and score confidence—this replaces unreliable post-processing and validation cycles.
- A production pipeline chunks the 10-K, runs a cheap extractor (regex or small LLM), batches Jev questions in parallel, then gates on confidence thresholds: ≥0.90 auto-stores, 0.70–0.90 routes to heavier review, <0.70 goes to humans.
- At $0.042 per million tokens with free output and sub-500 ms latency, a 50-page 10-K costs a few cents and processes in seconds—a practical advantage during the seasonal filing flood after fiscal year-end deadlines.
Fast, general-purpose classifiers like Jev can be used as temporary solutions for specific tasks, then replaced with cheaper, faster custom classifiers trained on the input-output data the Jev instance generated. This creates a practical path for engineering teams without ML expertise to eventually build optimized task-specific models.
- System One models solve the immediate problem of deploying classifiers without ML expertise or large datasets — you just prompt them like an LLM
- Once a System One model proves a feature works, you can collect its decisions as training data to build a specialized classifier that's faster and cheaper to run
- This pattern lets teams validate whether a feature is worth building before investing in custom ML development, reducing risk and upfront cost
TypeSafe AI released Jev, a new model class designed for automation that outputs type-safe structured decisions instead of text, running 40-200x faster and cheaper than existing LLMs on decision-making tasks. Unlike traditional language models, Jev can't hallucinate, always provides confidence scores, and costs nothing for output tokens.
- Jev achieves comparable intelligence to frontier LLMs on decision tasks while being 40-200x faster (70-500ms vs 3-329 seconds) and drastically cheaper ($0.042 per billion input tokens, free output tokens vs $0.20-$10 per million input tokens for LLMs).
- The model uses a new training method called Reinforcement Learning for Calibrated Decisions (RLCD) that optimizes for accurate probability estimates rather than human preference, and generates all outputs in parallel instead of sequentially, eliminating hallucinations and type errors.
- Jev trades away general text generation to specialize in structured outputs that slot directly into software workflows as fuzzy decision rules—classifying, routing, scoring, and branching without requiring human validation or parsing.
TypeSafe AI released Jev, a new type of AI model designed for automation and structured decision-making rather than text generation. It's 40-200x faster and 444x cheaper than existing large language models for specific tasks, with guaranteed type-safety and calibrated confidence scores instead of hallucinations.
- Jev generates all outputs in parallel rather than token-by-token, achieving 70-500ms response times versus 3-329 seconds for frontier models, while outputting structured data instead of strings
- The model uses a new training method called Reinforcement Learning for Calibrated Decisions (RLCD) that optimizes for epistemically honest probability estimates rather than human preference, making it reliable enough to embed in production software workflows
- Pricing is $0.042 per billion input tokens with free output tokens, versus $0.20-$10 per billion for existing models, with claims backed by publicly available workflow evaluations showing performance across complex automation tasks
Jev is a new AI model that only outputs structured data instead of human language, making it dramatically faster (70-500ms vs seconds) and enabling real-time applications like playing Doom. The author argues this speed advantage could become a new computational primitive for AI, though he suspects competitors can replicate it using simpler inference tricks on existing models.
- Jev generates all structured output in a single forward pass instead of token-by-token, achieving 70-500ms response times compared to seconds for standard LLMs, fast enough to play real-time video games.
- The speed advantage likely doesn't require novel model architecture—you can achieve similar results by prefilling responses and generating only one constrained token with existing LLMs, suggesting Jev lacks a substantial technical moat.
- Structured output could unlock entirely new use cases beyond chatbots by injecting "100ms worth of dirt-cheap intelligence" at decision points throughout applications, though Jev won't match frontier LLMs in raw capability.