Seems like a more accurate title would be "Jev: Trading general purpose generation for fast typed inference" or something like that.

This is interesting, but the speed comparison seems misleading? A generative model that can output code in a Turing-complete language can do anything a computer can do.

Jev can only generate structured output, right? This is probably super useful for classification/routing/scoring, but it's nothing like the code generating models we're all using today for code and automation.

Also "can't hallucinate" seems wrong? Sure, it can't emit an invalid type, but it can still emit a completely wrong valid value. You can enforce structured output from an LLM too, with an appropriate harness, etc.

Assuming there's no funny business, the Doom demo is cool.

Seems really cool.

For those who don't know (which is probably everyone but me), I ported the design-by-contract pattern in Python and combined it with LLMs. This was early 2025. I originally wrote about it here: https://leoveanu.com/2025-03-01-dbc/ . Contracts are a core feature of SymbolicAI ever since. The community seems to have loved it too (https://news.ycombinator.com/item?id=44399234).

I think I'm starting to glimpse the implications and it's gonna change agentic workloads if it holds up to scrutiny. It's too early for me to tell anything other than jot down some rough thoughts.

In short, you get blazingly fast semantic branching you can use in control flows. For contracts, I can now directly take the data model that you have to design and convert it into Jev's expected format. Or I can use Jev for semantic branching in postconditions.

If my understanding is correct, that should be doable, but I need to think more about it. It could be that with Jev I can finally “compile contracts” and better chain them into workflows, which is something I always wanted but didn't know how to do properly.

Eager to test. On the waiting list.

Unfortunately, none of this is explained in the announcement, but the documentation [0] is pretty good.

[0]: https://docs.typesafe.ai/concepts/how-to-build-with-system-o...

Oh, I have one of those use cases, matching people in genealogy trees. You can ask all sorts of questions: do the names match? Do they match within some edit distance? Do they match according to soundex/ metaphone rules (which are themselves a ginormous set of rules for letters and letter combinations which may or may not result in the same sounds, hand-coded as a huge if tree by a linguist not a programmer)? What about their relatives, do they match by the same rules? Should we incorporate domain knowledge about local naming customs? Etc etc.

I pointed a coding agent to this problem, and it aggressively started coming up with complex scoring rules and testing them against real datasets. Which led to sort-of acceptable results, but it still missed lots of cases which were obvious to a human, and had false positives which were obvious to a human. Which I could trade off, and slightly improve, with more back and forth with the coding agent.

Pointing a good LLM to all the information about two people, would of course give great results. Maybe even better than human judgment. But I can't do that for 100000^2 people, it would be too expensive in all sorts of ways. I need a fast, reliable scorer. I could maybe train an embedding, but that would be a huge job and where would I get the quality data?

It looks like the model takes as input a state (structured text? not sure if multi-modal) and a question (as a "Choice", "Score", or "Noul") with some additional augmentations possible. Then outputs the question's answers as appropriate (e.g. a choice, accompanying probabilities, confidence).

Edit: On the AI primer page, it looks like they do the RLCD on a pre-trained base model?

[0]:https://docs.typesafe.ai/concepts/system-one

Jev's focus on structured I/O and confidence scores are game changing. If this does at all what it claims, I think this is going to quickly become the new standard approach for agentic systems.

> Output tokens: FREE (too cheap to meter).

Insane. The video demos are really compelling, in particular the speed.

> Structured outputs slot into ordinary software as fuzzy decision rules: classify, route, score, extract, or branch where hand-written logic is too brittle. The surrounding code constrains their freedom, making them easier to compose into reliable systems.

I buy this vision. A lot of LLM integration I see these days is ultimately exactly this. OpenAI-style structured outputs works decently but this would be a great improvement in cost, latency.

also "70-500ms vs 3-329 seconds" are apples-to-oranges unless the LLM baseline is doing comparable work (e.g., long chain-of-thought). If Jev is skipping generation entirely for a narrow structured task, of course it's faster.

Nonetheless i want this to be true, so I'm looking forward to Jev

Edit: I really have to say that I like their manifesto https://typesafe.ai/manifesto

I need to rank 1000 articles and pick the 5 most relevant for the user? Jev.

I need to audit and strip out content because my user is affected by regional privacy laws (without hallucinating)? Jev.

I need to surface the 3 funniest media comments that match the user's sense of humour? Jev.

We already had encoder models that skipped text generation for giving us a numerical output that could be computed as a probability. we also got no hallucinations and faster inference for free there. So we already had

1. "unstructured state in, probabilistic decisions out" 2. "orders of magnitude faster and more efficient"

What was hard there was to train the model head without ML expertise, and considerable amount of data.

This seems like this is a democratization of those encoders? The addition over existing encoders seems to be coming from being able to specify the output shape (up to a cardinality of 255). It is unclear to me if this is possible using Jev without additional labels for fine-tuning.

If so, that is still very impressive, but I think the faster inference and 0 hallucinations might come for free, from it not being generative.

They claim it's not an LLM, which I read as "not an auto-regressive token generator". I assume they are still using a transformer, otherwise they would be talking about the thing that's not a transformer, instead of all the fluff on the linked page. But they emphasize parallel generation, so is it like a text diffusion model?

Yes, I think it's a mistake that many organizations are cramming LLMs inside of automated pipelines where the extreme generality/flexibility of the model is at odds with the fact that you're using it for a very specific task that gets repeated over and over, and needs a very specific structured output to be successful. But specifying your task carefully (as well as deciding what counts as your input state representation etc) seems like a form of programming. Something (a person or a model working in a relatively unrestricted way) will need to produce a configuration/specification for this system.

So rather than Jev vs Claude I imagine that using Claude/ChatGPT/whatever interactively to define / refine your Jev config which then runs in prod might be the happy combination?

This is something I focus on in a bunch of my experiments - how to get immense value out of tiny models (<1b params). There are lots of different architectures out there and there is so much to optimize if you know what you are asking and have a grammar to constrain with.

Great to see this and I hope this is a lot on top of what is already openly available.

FAQ: Is Jev just a smaller LLM?

Jev is neither small nor an LLM, hence being off the intelligence Pareto curve.

Image in documentation: https://mintcdn.com/ts-docs/aFVnpmCIX68NpsV1/images/ai-prime...

This is kind of trivially satisfied and they make this sound more extraordinary than it is. Also I suppose it can still hallucinate in the sense that for out-of-distribution data it will give miscalibrated probabilities.

Anyway a great step in the direction of calibrated AGI

The doom demo is quite cool

- is the capital of france paris?

- it is august. is it raining in paris?

(forgive the examples; they're probably not semantically the sort of thing jev is trained to work on. but i figure the point translates to various kinds of questions that come up in "inner loop of agentic pid controller" contexts)

a normal text-generating model if asked to produce a number will also do that just fine. i assume in jev's case it was actually rled to essentially learn to express priors over things using its implicit world model, which definitely ought to help, but can we say more?

Typesafe.AI sounds like some typescript/structured output type of tool…

What even is “system one” ?

IMO the product/tech is really there, just needs better communication.

If you work at TypeSafe please try this.

Side note: This is probably how LLMs would perform with better encoders and next-latent prediction, so eventually those will beat this architecture out. Still amazing though.

The one downside is that the context window is very small (32k.) So some initial ideas we had for initial evaluation of code reviews won't fit yet in the window.

1: https://swamp-club.com/extensions/@swamp/typesafe-ai

OpenAI has been teasing how fast computer use is with their models running on Cerebras chips but the difference here is a burning hole in your pocket.

Last 32k of connect + Summary of current task: Did we learn something useful here (true/false)? What is the category to file it under? Then notify the LLM to file it away.

What class of memory might be useful here? Model gives probability to each item in the list. Short description of all memories ordered by tagged class is used in the next round. Are any of these memories useful in the current context, such that they will inform the model and help in its task (yes/no)?

I’m sure there’s some fine tuning to be had, but this sure seems like the basis for a substantially better proactive memory system that works around an existing LLM conversation.

If I’m understanding what this does and how this works (generic input, intelligent classification with probabilities, rapid and cheap), this is absolutely nuts.

Just joined the waitlist, excited to try it out!

Here's how this would have likely been made.

- Tiny transformer or equivalent model (maybe a few bn or so?), explaining latency and cost

- Questions are sent in parallel to multiple copies of it (I'm sure they're edge located)

- The model is post-trained for calibration in a wide variety of data (the recipe is relatively simple, and likely targeted on distillation of logprobs / confidence of a bigger model)

Notice how cost is ONLY for input tokens as output is merely numbers (few tokens) because input could be huge (questions and options).

At 0.042-per-million price they have, Astra estimates the model to be 3bn parameters.

One could replicate this by post training Qwen 3.5 2Bn. I expect people to do so soon!

Then, you can serve it faster/cheaper than the frontier LLMs. It's basically distilling a small but extremely common use-case from LLMs and serving it. Then RLCD comes into play to update weights when a new model comes out, etc.

Any thoughts on what the next potential "cheap" win to be distilled from frontier LLMs is? I'm going to need to play around with this.

> [them] Output tokens: FREE (too cheap to meter).

I'm very confused by this.

That would be the litmus test.

"Does not hallucinate" is not the same as "is never wrong".

So the ATC test could be the benchmark.

[0] https://goodstartlabs.com/research/verification-is-the-bottl...

Surely it’s still generating some kind unstructured data internally? For example, what if I told it to generate a short story, but the short story is output as a JSON string?

Edit: never mind, found https://docs.typesafe.ai/introduction/quickstart by now

My guess is that due to its design there is no support for prompt caching, as there would normally be no reason for it. So the performance of my idea would probably be appalling as every step in the loop would reevaluate every input and output token. But it would be interesting to see the outcome.

But in things like programming, most concepts are abstract - 'if hungry eat an apple' in programming terms would look like

'if hunger > 50 {apples--; hunger-=30;}'

and compilers work with 'concept erasure' - to them, tokens (which are like llm tokens) look like

'if var1 > 50 {var2--;var1-=30}'.

They don't care about how these things map to real concepts. So all the embedding directions used to encode real-world concepts are just noise to LLMs when programming. This greatly reduces dimensionality and training costs. So does a token representation tuned for programming constructs, rather than natural language would probably have a more efficient encoding.

https://substack.com/home/post/p-215252866

You architect your systems with typesafe - because it is marginally faster, but inaccurate - to do what ? You can just wait for the next version of LLM's to get more accuracy at the same cost - or just use a faster model right now from a different provider.

Finetuning a language model for decision classification (with probabilities) is already well-understood. What specifically changes in the training objective with RLCD? Are its benefits isolated from Jev’s new architecture/parallelism?

I'm curious to hear his take on this approach.

"Does this contract contain ____?" is a pretty typical query for many industries, and then you can have follow up questions that nest down into further info about X, Y or Z thing.

Looks really good for that use case, especially with certainty as part of the output, as you could flag things that didn't have high enough of a certainty to human review.

I'm sure legora and the other legal AI tech softwares are all over this.

The goal is going to be to use llms to distill operations down to some dsl, and pass it into something like Jev.

Is there anything published on how it maintains calibration? Or when you say "outputs calibrated probabilities" you mean "as calibrated as frontier LLM models, just cheaper" - which is a different claim; as LLM's aren't particularly well calibrated

However I don't understand how are they claiming zero hallucination, how does giving confidence score fix hallucination? or am I missing something here?

This is a valid tradeoff for one-off responses but if we're dealing with a distributed system (eg: Kafka), then only the high-confidence responses (>0.8) should move forward as input to the next service. If a low confidence output is propagated, then it can break the entire chain.

On a more serious note, it will be fascinating to see how this different spin on modelling inference will create new paradigms or slot into existing ones.

It might be boring, but I can see exactly how I could use this right now to improve my agentic rag.[0] In two months I am supposed to deal with a giant corpus, while still maintaining responsive chat UX. I have been working my butt off to make our first big client happy. This could really help solve the chunk ranking problem.

[0] assuming the policies are compatible with sensitive production workloads, some time in the near future.

Given that, can't you just replicate Jev by telling Astra "here is the question, you must make a multiple choice decision / output a score between 1-10, please answer directly in a single word, no reasoning allowed"?

(Edit: Ok, Jev is much cheaper in input tokens so these two aren't directly comparable at all)

I think this could be pretty decent in CI? There's a lot of "flakes" I've mediated that this could have handled much more efficiently. Maybe observability as well, triggering elevated logging and other initial measures?

I like the idea of System one models but all LLMs so far work as system 1 thinking because humans generate speech subconsciously with system 1.

System 2 thinking requires consciousness which AI does not have, so even reasoning models are still system 1 thinking as system 1 in humans has reasoning with heuristics.

Its limited but most people navigate the world with it completely, so it's enough for AI.

I've been collecting what people built with it in the first days: https://madewithjev.com

feel free to add your demo or project.

I listened to "Thinking fast and slow" recently and I was surprised how closely in behavior a LLM approaches the "System One" as defined there.

I approve of the clever branding!

Such large advances shouldn't be locked up away from local hardware.

lol, I bet they would publish them if their score on those benchmarks were good.

LLMs are universal simulators, their latents model the world. So I bet if you compare their logprobs with probabilities output by this model, it will be highly correlated.

Someone should do this quick experiment. I bet there won't be enough of a meaningful difference.

[1]: www.expressionsofchange.org

https://fastino.ai/blog/gliner2-5-span-free-information-extr...

im thinking about how well Jev could be used to replace a current LLM-as-Judge evaluation workflows, specifically on chat transcript data (think ~1,500 tokens) i wonder if the reasoning usually required pushes it a bit out of scope. didnt see anything published about constraints on the state size, so would be curious to hear about that.

Jev input … > Unstructured data (e.g. text) with an emphasis on structured program state.

What pre-training data/model is Jev based on? Surely result effectiveness is dependent (outside of one’s own input as “state”) on that?

I’m guessing it might be able to replace maybe 40-70% of LLM calls for a given pipeline depending on the business task, cutting the API costs on those calls by an order of magnitude.

Couldn't you hook it up to a multiple choice exam?

It's still LLM like, how smart is it? I'm wary of something that the company states they don't want to benchmark it across public benchmarks.

I'm very curious how much ressources are needed to run such a model. This could be a complete game changer for local applications.

I think the interesting thing would be seeing if prompt injections still work with this kind of model.

1. Do you provide any kind of largest common subtree caching for cheaper input?

2. Have you tried auto-generating Lisp programs structurally?

3. Have you tried augmenting a Lisp language with a `choice` function that makes choices given a prompt, the environment, and the continuation stack?

I think we'll see a bunch of different architectures over the next five years.

edit: looks like a framer export where there is a text stroke being applied :|

0. https://typesafe.ai/

1. https://en.wikipedia.org/wiki/Fast_inverse_square_root

Either way, really cool and impressive.

The idea sounds cool though

> Search for relevant information over giant corpuses

Do you mean as an alternative to embeddings?

Yes, that’s the kind of attitude I want to see in these model releases

https://docs.typesafe.ai/concepts/use-case-map

This website does not inspire confidence at all, it all sounds like a marketing piece. I wish it was true, some kind of text-prompted classifier with LLM performance would be cool, but I can't trust it with what we are given.

forget LLM benchmaxxing sidequests, I'm sold on the real benchmark

Does this imply it's a very small model? I couldn't find anything about the model itself.

it can generate classes/models/routers etc via tool calls, doesnt write the actual code.

> LLMS > Strings / generated text. Strings are flexible and can be anything: chat responses, code, hallucinations, refusals, or even type-safe structured values. To be used by software, responses need to be parsed + validated. There is also always some risk that the AI goes off the rails.

> Jev > Type-safe structured values. Possible outputs and structure are defined in advance. The model never makes type errors. All answers are accompanied with calibrated probabilities and confidence scores.

I mean, this isn't even remotely comparable to LLMs so why compare? Also, why are they bringing up AGI given there approach is so restrictive that what they're building literally cannot have the creativity required for AGI? The video is 100% marketing slop...

The bulk of the application of LLMs is that they generate reasonably reliable text which doesn't need to be defined in advanced. I'm sure there is a niche for this and congrats to the team, but please let's not hype this as if it's the next big thing in AI...

> we assume there is a correct compute graph (a “workflow” represented in code) and use the predictions of the largest, smartest, and most expensive external models as reference probabilities. ... Rephrased: every model gets the same workflow. We test how they compare to the average of the smartest models (in this case, Astra and Fable).

They assume there is a correct graph, but they don't compare to that, they compare to the average of the smarts models? So the smartest models are getting it wrong but you compare that anyway as a benchmark? So the outcome is "how much of a Fable am I getting" etc. Why not compare the actually correct thing?

But then even on this hand constructed eval, the first plot is showing Jev at less than Sonnet 5 accuracy. It is barely better than Luna. There are two Opus 5's and two Sonnet 5's without explanation. What is the plot showing?

I gave up.

Ouh! Any open weights models that can do this yet?? If not, how much longer? I have a Mac Studio coming soon.

https://x.com/CompleteSkeptic/status/2099925682726002904

But is it just me or other folks feel uncanny seeing "a machine" playing Doom with low-latency as the first demo.

While I'm optimistic that humanity is good (but sometimes makes bad decisions), My first thought was seeing such models used by armies.

I'd use this as a tool an LLM can use for specialized tasks. It's not AI in itself.

https://docs.typesafe.ai/primitives has a much better explanation