Guido Frigieri

Growth | Long Term Investor | Former biotech guy (EMBL/UNIBO)

[Nicola Sosio @nicola_sosio]

Writing the change was never the hard part. Proving it was.

Today we're launching Kosuke. A sandbox per change, your full stack running inside it, a preview anyone can click.

https://t.co/hrMUHqiK1d

[Guido Frigieri @IoGuido]

@typesafeai JEVVVVVVVVVVV

[TypeSafe AI @typesafeai]

Jev is now available: https://t.co/5MfN4rIif5

[Guido Frigieri @IoGuido]

Time to run guys that's your opportunity

[TypeSafe AI @typesafeai]

Jev is now available to everyone. No waitlist.
Start using it here: https://t.co/5MfN4rIif5

[Guido Frigieri @IoGuido]

@typesafeai The entire world rn

[Jσsh @JoshKuechly]

I don’t think Jev will survive.

@nvidia and @meta will release open-source Jev competitors within the next 30 days.

@OpenAI will add a Jev-like endpoint to their model list in the next 60 days.

And the rest of us will fine-tune custom classifiers that crush Jev and are 10x faster.

In two years we’ll look back at this flash-in-the-pan and say

“remember Jev?”

[Guido Frigieri @IoGuido]

@MatijaSosic

[Guido Frigieri @IoGuido]

@damonchen

[Guido Frigieri @IoGuido]

@nutlope

[Guido Frigieri @IoGuido]

@0xRicker

[Guido Frigieri @IoGuido]

@OpenRouter @typesafeai

[kwindla @kwindla]

.@jonptaylor recorded a detailed walkthough of Jev vs GPT-5.6 Luna as the "operator" element of a Pipecat speech interface pipeline.

GPT-5.6 Luna:

- 81.3% command accuracy
- 1,008 ms median latency

Jev
- 92.6% command accuracy
- 296 ms median latency

A few notes here ...

1) We expected to see a big latency benefit. But the higher accuracy is maybe more interesting. Jev (with a bunch of code wrapped around it) is much better at turning messy transcriptions from a noisy speech environment into correct command structs.

The very hand-wavy explanation here is something like: LLM tool calling is an amazingly flexible, general capability but is only one thing that LLMs are trained to do. Jev is trained to do a narrower thing: to produce probabilities over a fixed set of options.

If we can express our tool calling requirements as fixed set of choices, it's perhaps not surprising that the model trained specifically and only to evaluate choices does a better job at that task.

Some keywords to talk to your friendly neighborhood LLM about this topic, if you're interested in a deeper dive, are: discriminative vs generative models, calibrated probabilities, constrained decoding, and closed-set vs open-set prediction.

Note that this is GPT-5.6 Luna without reasoning enabled. With reasoning, today's LLMs are going to do much better on evals like this. Reasoning lets models build a scratch pad of options, which is massively helpful in classification tasks. But we generally can't use models in reasoning/thinking mode for applications like voice agents or voice user interfaces, because the latency is too high.

2) An application-specific eval lets us make informed choices about whether we're getting measurable benefits from different models and different architectures. It's gotten a lot easier to build pretty good, very specific evals as part of agent development. Fable and Astra know how to do this and mostly get things right without a lot of guidance.

3) Using Jev feels more like programming than using an LLM does. Mostly, with LLMs, we're doing "context engineering." Which is just a fancy way of saying we're trying to feed the LLM a big pile of natural language and hoping we're aiming for the right part of the latent space.

In most of our sophisticated agents, there's a lot of code to do this context engineering: constant summarization, switching prompts for different parts of the conversation, etc. But the end result is always just really long prompt strings!

With Jev, we're sending the model natural language, but in addition we're doing very explicit mapping between application state and Jev's input data structures.

[Guido Frigieri @IoGuido]

@BLUECOW009 It's crazy good

[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.

[Matthew Berman @TheMattBerman]

jev is INSANE.

in 40 seconds it broke down 724 live ads from 37 brands.

every hook. every format. offer. cta. awareness stage. landing page mismatch. used 9 cents of tokens.
(will be avail in @stealads + mcp)

[Diogo Almeida @CompleteSkeptic]

After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI?

I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev

• 20-200x faster
• 40-400x cheaper (w/ output tokens free)
• Frontier composable intelligence optimized for decisions

AFAICT the shortest path to AI-based economic revolution

[Guido Frigieri @IoGuido]

Jev by @typesafeai reached 13% of teams on Vercel AI Gateway in 24h

But how?

It probably helps that the team includes the co-inventor of RLHF and InstructGPT - @CompleteSkeptic also League of Legends god

And in TypeSafe’s own workflow evals, Jev was 193.6x faster and 444.6x cheaper than the LLM baselines

[Guido Frigieri @IoGuido]

@Bhavani_00007 Just a slot machine with the results

[Guido Frigieri @IoGuido]

@deepseek_ai Here we go again

[Guido Frigieri @IoGuido]

@zachlloydtweets We use the same principle in https://t.co/OjfLdHV5Ji any stack , any model your dev environment on cloud ☁️ we were early one year ago but now it's the time