Retro Man

[AVB @neural_avb]

Releasing bev-decision-150K - a high quality dataset to train decision models (like JEV)

Contains 150K examples across diverse domains, tasks, question types - either procedurally or synthetically generated from existing LLM training open datasets.

https://t.co/3BMPwVmzxZ

[elvis @omarsar0]

Pay attention to this new wave of System One models if you are building custom harnesses.

First Jev. Now, Contrastive Language Model (CLM).

CLM is 9x faster than Jev.

CLM seems to be a better verifier than Jev, particularly at long-horizon tasks.

How do Jev and CLM differ?

CLM is contrastive, and Jev is trained with Reinforcement Learning for Calibrated Decisions (RLCD).

Jev receives a situation plus predefined questions, and returns typed decisions with probabilities. CLM embeds the situation and candidate actions, compares their similarity, then ranks or selects the best match.

The point is that there are several ways to attack this problem, which is exciting.

You can see my recent guide on combining System One and System Two models for building custom harnesses. https://t.co/Ccy5o4s6QU

[Fastino Labs @fastinoAI]

Introducing GLiNER2.5-Decide, our new 340M parameter open weight, encoder-based decision model.

GLiNER2.5-Decide is built for fast, deterministic classification. The model evaluates a set of user-defined typed questions and rules, and jointly decodes their answers, returning structured decisions with probability distributions and confidence scores.

We evaluated the model’s performance on Fast Decisions, an unseen, internally generated classification suite based on 17 datasets testing real-world use cases across routing, triage, classification, sentiment, and content understanding.

Measured against similar decision models, GLiNER2.5-Decide leads in 9 of the 17 datasets, achieving the highest average score:

- GLiNER2.5-Decide: 60.1%
- SemIf: 56.4%
- JevK5: 57.5%
- Laya: 46.6%

This performance makes the model a strong fit for use cases like tool calling, model routing, browser and computer use, and LLM-as-a-judge.

GLiNER2.5-Decide’s lightweight encoder architecture makes it easy to fine-tune the model for specific tasks, while being efficient enough to run locally on consumer-grade CPUs or in air-gapped environments, giving users greater control over where their data goes and where the model runs.

To make building and experimenting with GLiNER2.5-Decide as easy as possible, we're also offering hosted inference. You can now use our API to run inference and fine-tune GLiNER models on specialized tasks right inside your own coding agent: https://t.co/sy82U11REr

As with previous models, we’re also releasing the model weights on @huggingface under the Apache 2.0 license: https://t.co/vKS9tsZpiF

[TypeLLM @TypeLLM]

Jev can’t do any of these:

1. Image inputs
2. String, integer, and number types
3. Dependency execution in a single call

TypeLLM can.

Try it: https://t.co/cDBr9Eja9D

[Hassan @nutlope]

Announcing tev1-4B-experimental, a Jev-like classifier finetuned on top of Qwen3.5 4B for only $17.

I'm releasing everything: the weights, data recipe, & a full tutorial on how to train your own.

You can try it today on Together serverless at $0.042/1M input & $0/M output.

[Azalia Mirhoseini @Azaliamirh]

Introducing Contrastive Language Models (CLMs), a System 1 model that connects actions and states!

Agentic coding: with lightweight finetuning, CLM-8B sets a new SOTA on DeepSWE (81.6%) and Terminal Bench 2.1 (87.6%).

CLM-8B vs. Jev: comparable zero-shot performance on computer-use, gaming, and tool-calling tasks, while being up to 9× faster.

We are releasing the CLM-8B checkpoint, its data, and infra today!

[Hassan @nutlope]

https://t.co/1O203j62Oz

[Jacky Kwok @jackyk02]

Introducing Contrastive Language Model (CLM): an ultra-fast System One Model trained with a contrastive learning objective that connects states and actions.

CLM-8B is pre-trained on internet-scale data and delivers up to 9× faster inference than Jev ⚡ while achieving comparable performance across computer-use, gaming, and tool-calling tasks.

With lightweight fine-tuning, CLM-8B sets a new SOTA on challenging agentic coding benchmarks, such as DeepSWE (81.6%) and Terminal-Bench 2.1 (87.6%). In contrast, Jev fails to serve as an effective verifier for these long-horizon tasks.

We also build an efficient training and serving infra for CLMs by disaggregating states and actions, allowing their embeddings to be cached and reused independently. This substantially reduces inference latency in settings where the state evolves continuously while the action set remains fixed.

Finally, we establish scaling laws for CLMs and show that the test contrastive loss decreases predictably as a power law in training compute, model size, and dataset size.

📄 Blog: https://t.co/zwi9JOHKGx
💻 Code: https://t.co/rsHRYCGR8I
🗣️ Discord: https://t.co/Uqtdefvo3J
🤗 Data & Models: https://t.co/wdSWGGO3hu

More details on CLM’s architecture, data recipe, and scaling laws in the thread below 🧵

[netrunner @plotarmordev]

Another Jev competitor just dropped: CLM-8B from @jackyk02 and the Stanford/NVIDIA team, with open weights under Apache 2.0.

They claim it's comparable to Jev with up to 9x faster inference

We went from zero options to a new one almost every day!

[vLLM @vllm_project]

DiffusionGemma-Jev now runs on vLLM 🚀

Ask yes/no, multiple-choice, or scored questions and get confidence with every answer. vLLM seeds a canvas with the response template, leaves only the answer slots noisy, then reads a probability distribution from every slot in a single denoising step.

Huge thanks to @mmastrac for driving this upstream! 🙏

https://t.co/HJJz0Q2KYe

[Akshay 🚀 @akshay_pachaar]

LLMs vs. Jev, clearly explained!

TL;DR

The key difference is not that Jev generates faster.

Jev does not generate text at all.

A traditional LLM receives context and produces an answer one token at a time. Even when the output is a small JSON object, every token depends on those generated before it.

Jev receives the same context but evaluates predefined decisions directly. When those decisions are independent, it can evaluate all of them in parallel.

Consider an agent handling a failed deployment. It may need to determine:

→ Whether the incident is urgent
→ Which team should handle it
→ Whether the proposed command is risky
→ Whether the task is complete

An LLM generates a response containing these answers sequentially. The application then parses and validates it.

With Jev, you define the questions and expected answer types upfront. It evaluates them together and returns typed answers with probabilities.

Jev supports three decision primitives:

1. **Choice** selects from known options, such as engineering, billing, or sales.

2. **Score** places the input on an ordered scale, such as low, medium, or high risk.

3. **Noul** evaluates a yes-or-no condition and returns the probability that it is true.

The probabilities matter as much as the selected answers.

If engineering receives 91% probability and billing receives 9%, automatic routing may be reasonable. If the probabilities are 52% and 48%, the system can escalate, gather more context, or call a stronger model.

This keeps control inside ordinary software.

Code owns the thresholds and consequences. Jev supplies the semantic judgment that a normal `if` statement cannot derive from unstructured text.

It works best when the possible answers are known, the decision depends on meaning, and a careful person could judge the input quickly.

It is not designed for writing, summarization, code generation, arithmetic, or decisions requiring several dependent reasoning steps. Independent questions can run in parallel, but decisions that depend on earlier results must remain sequential.

Jev also cannot return an option outside the declared schema, but it can still select the wrong valid option. Type safety prevents malformed outputs, not incorrect judgments.

The clean mental model is this:

LLMs generate new language when the answer space is open.

Jev evaluates known paths when the answer space is bounded.

I wrote the full breakdown explaining Jev and where it fits.

The article is quoted below.

[Richelle🚢 @Richelle_Ji]

Jev, now with open weights + vision.

Classified 1,697 SF Tech Week events with Gemma 4 26B-A4B.

Zero labels. No fine-tuning.

Jev-ify any open-source model on SimpleJev.

[Shann³ @shannholmberg]

here's how JEV works, simplified

I've been experimenting with it for the last hour, and it's EXTREMELY good at making decisions with the right references and context

you give it the information, your questions, and the type of answer each question needs:

> a choice from options you provide
> a score on a scale you define
> a probability that something is true

the models we're used to often give us long written answers, with explanations and reasoning

jev returns structured answers your app can use directly, instead of generating those explanations

information + your questions + allowed answers → answers your app can use

you define what happens next, based on those answers

that could mean sending information to the right place, checking an AI agent's work, or flagging something for human review

because jev doesn't generate prose, it doesn't invent facts or sources inside a written explanation (hallucinations)

clear questions and useful context matter, including references that explain what it should check

I'm seeing so many cool use cases across X, and I can see people adding this to all kinds of existing apps

if you haven't started building with it yet, try it on one decision your app already makes

[Vivek Galatage @vivekgalatage]

The details about how Compiler Explorer works are fascinating and absolutely amazing

https://t.co/oaeow7m7z5

[Alex Lavaee @alexlavaee]

Jev explained in under 10 min: what it is, how parallel constrained decoding works, when to use it, and when not to.

Shoutout to @NielsRogge + @gregpr07 for the great diagram + demo used in the educational video.

[vartekx @vartekxx]

Google just dropped a 12-page PDF on Agentic Engineering - building agents and agents teams that will change your life

here's the 5-stage Google agentic engineering pipeline:

stage 1 → specification - define success with tests and automated checks

stage 2 → harness - give the agent tools, prompts, guardrails, and everything it needs to act

stage 3 → trajectory - let it execute the full workflow instead of judging one response at a time

stage 4 → verification - run linters, tests, and semantic checks before accepting the result

stage 5 → meta-debug - when the agent fails, fix the workflow, not the model

the shift is simple:

stop asking "which model should I use?"

start asking "what system do we build around the model?"

Read this 12-page PDF before building another agent - it breaks down five real Google systems most agent tutorials never show

save now, then read how to build your first agent in the article below

[PyQuant News 🐍 @pyquantnews]

How calculus works in one picture:

[Arika @Arikalabs]

be dennis ritchie

> create C
> co-create Unix with Ken Thompson
> give generations of programmers the foundations to build on
> win the Turing Award
> your work reaches billions of people who never learn your name
> die in October 2011, while the world is mourning Steve Jobs
> your death makes far fewer headlines
> somewhere today, someone writes their first “hello, world” in your language

imagine building something so lasting that people begin their life’s work inside yours.

[Kirk Borne @KirkDBorne]

🔵AI Agents in Action: https://t.co/dALPmfHTWH v/ @ManningBooks

🟡New! Updated! 2nd Edition!

🟢 Table of Contents:

Chapters:
1. The rise of AI agents
2. Core components: Large language models, prompting, and agents
3. Actions with Model Context Protocol for AI agents
4. Architecting and building multi-agent systems
5. Agent reasoning and planning
6. Working with memory & knowledge RAG for agents
7. Building robust agents with evaluation and feedback
8. Deploying agents and agentic systems
9. Understanding the agentic loop
10. Exploring the cognitive agent that thinks, monitors, and adapts
11. Tips for building agentic systems

Appendices
A. Setting up the sample code repository
B. Node.js setup for local MCP servers