I linked to the tweet that has the video because if you are not signed in you cannot see the whole thread of tweets.

I can see the individual tweets in the browser while not signed in though.

The doom demo is also in the article, for anyone that doesn't want to go to X.com. :)

Link to a raw MP4 of the video, from the parent article: https://framerusercontent.com/assets/rlL7ImEbISFoYt3IJEHHfvj...

It's in the parent article under a section named "Doom" in case that asset URL ever changes.

i think its just telling the model that it cant output a shoot action

It wasn't until the demo videos that I realized the post wasn't satirical.

Flip both, Cario Vmodei.

Wild that it doesn't generate text. I wonder how its technology compares to Tesla's FSD stack.

Signed up for the beta! :) would love to put this through some real-world shootouts against traditional LLMs to see where this type of model really excels.

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.

https://typesafe.ai/blog/antibenchmaxxing

But also effectively this is a classification model. It excels at specific certain types of workloads, and obviously will fail at others. Not really sure how one benchmarks this tbf. I can see their argument on why this requires a novel specific eval for whatever your usecase is. A consistent "global" benchmark might be hard to do

Looks like a great model for NLP.

The whole video seemed generated to me

definitely not AI-generated - this is my real wardrobe

we also thought the voice at the end was AI-ish, but apparently that's a real voice actor but slightly sped up

Pretty sure that's an intended joke.

Reminds me of this: https://www.reddit.com/r/ITcrowd/comments/tg05j1/i_cant_beli...

Cool project!

That's what I was insinuating through "better encoder"; the model creating more efficient representations of ASTs using something like JEPA

Yeah it would be quite trivial to try and implement an auto regressive AST generator for STLC with Jev provided that you had bounded variable names and integers.

As you said, if it worked, they would have demoed it haha

I could see Jev being great at finding key symbols in codebase before a code generation/code review task. I sent you guys an email (to hello@) about using Jev in Code Review for www.ellipsis.dev.

There was no "AI Winter"

join the discord! we love forward thinkers

I could put this to use today.

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

The doom demo shows the program state / query.

It's a bit hastily put together, but I made a dspy fork where you can add a decorator to automatically use TypeSafe where possible on Signatures. It shows a fair bit of what actual, hands on usage looks like.

https://github.com/typesafeainate/dspy-typesafeify

Super intrigued by this - large scale automation using LLMs is quite annoying due to deprecation cycles of models from frontier labs and cost of running your own being prohibitive when you have a blend of them.

The thing is, in this climate it's hard to believe such tech will remain secret for long.

So, assuming this is not vaporware, this would raise the tide for everyone because it shows what's possible.

You can set privacy requirements and define an allow list. To me the main value prop is that I get one bill for all models and can quickly try new models without signing up anywhere or changing my code. Oh! Also you can pass an array of models and if the first provider is down it automatically falls through to the next provider. More useful than it should be...

I always setup guard rails so that only zdr providers are used.

They don't like adding stealth startups :(

They have various benchmarks, e.g. how much time it takes them to do wikipedia page -> page games. Jev seems to take the same or fewer hops but in ~10x less time and for ~10x less money.

It's totally reasonable to compare against LLMs doing chain of thought if it gets comparable performance.

It's not an LLM though it's a frontier model on structured data

so what? put an LLM on Cerebras and get its responses faster, and put Jev on Cerebras and gets its responses even faster

love that you love the manifesto! letting the first batches off the waitlist now, but we do have some early users describing their experience (https://x.com/danshipper/status/2099947471518474522)

they’re talking about two totally different things, right?

it's our output tokens that are free (under the system one / jev column)

What is it about the rendering of this page that is so... off? It almost looks like the entire thing is a <canvas> element.

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

Bingo. It's a Psychology term for the part of our brain that reacts instinctively rather than thoughtfully and logically

If you zoom in (especially on the large title), you'll see that the text is a semi-transparent gray with a black internal outline. It seems like all the typography is SVG-rendered. Actually insane. I've never seen this before. Not even the most vibeslopped websites have that.

We deliberately chose not to publish performance against public benchmarks. In fact, we plan to only have one-off evals when we make product updates.

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

"is this the real thing or is just fantasy"

yup just joined the waiting list with a very similar use case in mind

it is just a model, no harness yet ;)

it is a structured data model, but technically not a language model (it doesn't generate language)

If you provide it an AST of the english language, yes.

you could, but it the model is not optimized for text

this is complex, but generating text is highly complicated and requires mode dropping to make long cohesive text

Strings trigger us

It looks like a specialized encoder-only(-ish) transformer with scalar and ordinal output heads. Acausal in effect, maybe? Probably not even autoregressive?

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

If this is true means, AI Stock bubble burst. (For good)

1. I am extremely on the same page 2. I do think that subconscious is not only much smarter than we give it credit for, but also much more robust than the "jagged frontier" of current LLMs

(shilling my blog post on that jaggedness: https://www.completeskeptic.com/p/lies-damned-lies-and-bench...)

I think that's to demonstrate its speed

very accurate!

the one nuance I'd get into is I'd call it "zero-shot" over "instruction-tuned" (the latter often implies a particular distribution), but very safe for sharing

architecture is close to the chest for now, but we have talked about writing a paper

I don't want to shill my blog too much, but I will say data is probably far most interesting than architecture: https://www.completeskeptic.com/p/the-bitterest-lesson

I assume this isn't really for consumers/individuals currently? Kinda feels like an improved magic 8 ball.

I can't really intuit how I should think about when the model will be accurate. Is there somewhere to read more about that? I assume customers would just have some tests or talk to you.

If this is true, then AI Stock Bubble burst (for Good)

Yeah, it doesn't output strings, just decisions/answers.

Outputs

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 have played with this! the fascinating thing we've found so far is that adversarial examples for our model are quite different from that of LLMs so that they work even better together

So an encoder-only model with a classifier trained on the heads or something? DeepSeek recently switched to an encoder-decoder architecture in an attempt to get the best of both worlds (fast prefill while preserving generation capability), I wonder if that might be the future?

That was the first thing that come into my head. OK I can train very simple model, that can generate json's for specific tasks, so what? How we can be sure that this "limited use cases" not just overfitting for particular outputs (or even distillation?)

Except this, this thing looks like revolution.

oooooh it can play Doom!

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

That's kinda the goal. Imagine all the automation in the world being able to embed intelligence directly inside it - factories could route based on more complicated questions, hardware could anticipate your needs. Customer support could be done without humans 90% of the time.

Funny how it can do everything but not chat. Sort of how when I was a kid I thought of a medicine that could cure any disease except the common cold.

this is interesting, so not an LLM but can be used in these use cases that LLM's have been shoehorned into

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

exactly right!

Jev can only generate structured output, right? This is probably super useful for classification/routing/scoring,

My first thought was that it would be ideal for robotics? As in control of limbs, general planning, route finding, etc.

that's right, but because these models are probabilistic, it's also possible to be confidently wrong (and all future models will be smarter still and still have that possibility)

Technically speaking when you send the prefix “The capital of France is “ into an LLM it will also produce probabilities across its whole vocabulary.

Yeah but what stops it from producing confidently incorrect outputs...

From a quick look at this it looks like it could easily generate natural language text by following a structured representation like UMR (Uniform Meaning Representation) or the similar representation the Abstract-Wikipedia folks will be working on for generic encyclopedic text (which will be heavily informed by Universal Dependencies). These are basically linguistically principled and frame-based counterparts to a programming language AST, that can be then converted to natural language (in a broadly language-independent way, to the extent that semantics and pragmatics make that feasible) via some sort of NLG rendering.

(To be clear, this one raw model does not support outputing a full AST directly - it wants to output "choice" among fixed options, "score" on a sliding scale, or a true/false answer (all of these with confidence scores attached), so building the AST/structure would be a code-driven (or even perhaps outside LLM-driven in some more challenging cases) multi-step affair where the model would essentially be playing a "game" of building the structured output step by step and getting a revised partial state back. But one could expect this to lead to interesting results.)

Just to be sure that I understand, you're saying that your model "can't hallucinate" because it only outputs a single thing, right? In this way, an LLM can't hallucinate either if I prompt it to do a classification task with a discrete set of possible outputs, right? (Assuming I reject non-conforming output. Actually, maybe what you're saying is that your system can't output non-conforming output?)

I'm biased but I wouldn't call it misleading

- @CompleteSkeptic

Very strange.

Hallucinations were defined in the context of text generation models so your question does not really make sense.

IMO your system can make mistakes that are similar in spirit to hallucination (i.e. answering with a false answer instead of abstaining to answer).

Let's say classifiers don't hallucinate. To make a fair comparison we should constrain LLMs to the same classification task. In that case, no, LLMs also don't hallucinate.

- Give Jev and LLM the same input

- Lock down both to approved/rejected/unknown (LLM restricts on decoding)

- Both can be wrong, but neither can hallucinate (invent an another option).

I dunno, I would consider Waymo and Tesla to have frontier models.

I think AlphaFold and related are also frontier models.

Being an LLM does not seem like the qualifier for frontier.

How is this not a frontier model? It's bleeding edge in its own niche. It's not a frontier LLM; however, applicable to many of the things people use LLMs for.

Large language models are not the only type of model.

I feel like the power of the approach presented here is that it gives a model a proper "language" to describe computations directly vs moving tape silliness.

I foresee this to be the path moving forward - giving AI models understanding of the computation directly(as well as compositional rules) This feels like a short path towards total software in many areas.

So... a classifier model?

Will need hands on to truly tell, but the doom demo seems very promising. If it can play that with text descriptions of where stuff is by distance and degrees in a 3D context then many GUI automation tasks should be easily doable

Not in the traditional sense of a coding agent, but we think there's a ton of opportunity in using it for context management ("do we _really_ need to pass all these tokens to the agent?"), semantic linting ("how does this score against this AGENTS.md: <...>"), etc.

What's the difference compared to just taking an embedding and feed forward a simple net trained for the task?

we hope so! the bigger hope is to not just eat LLM market share, but to allow for people to use AI much more in the inner loop of software

Congrats on the release!

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?

Interesting concept, I can't see a reason to use a generalist classifier over an api rather then just training my own? If it was open weights I would probably mess around with it.

thanks a ton!

constrained decoding (OpenAI-style structured outputs) make models dumber unfortunately - the short+dense version is that simply masking logits is insufficient because if ever a model was assigning probability to an invalid token, the model is by definition confused. you'd be better off erroring IMO

If I’m understanding correctly, this will work well for self driving cars?

I’m not understanding what this is. It’s a faster cheaper LLM?

Congrats on the launch! What's different between Jev and Microsoft's Guidance package? https://github.com/guidance-ai/guidance Is it a diffusion generator under the hood?

Is there a downloadable technical report somewhere?

From the person in the video regarding issues with benchmarks in general, and for LLMs. Also their approach. Good article.

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

We had early access and found it to be pretty useful. Having a second form of verification, where you can ask multiple questions (in the form of Nouls) raised our confidence in the outputs of other models. [0] IMHO This type of model works incredibly well in concert with LLMs, not as a replacement.

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

Current models go beyond the simple embedding because you start to encode groups of concepts in the context-aware part of the model (attention heads or any other method). So it is never simply words/tokens in isolation anymore.

inputs are structured program state. there is an example at around second 30 of the doom demo

(though ideally everyone gets off the waitlist and can try it out for themselves )

I mean, it's a structured output model that (apparently) can't hallucinate. I don't mind the name.

The model can't reason comprehensively (e.g., like Sol XHigh would to solve a complicated problem), but it's designed to be able to answer anything a human reasonably could quickly and intuitively, i.e., system one thinking: https://en.wikipedia.org/wiki/Thinking,_Fast_and_Slow

I don’t see this as an option in their website

You could theoretically ask “what is the next appropriate character?” and add the entire ascii charset but i doubt it’d work well and you’d be implementing autoregressive churn across network latency…

strings (and all sequential data structures) are not allowed at all - this is how we make sure all outputs can be computed in parallel (thus no output token cost)

"While Jev gives up string generation, it’s optimized for structured outputs and can’t hallucinate"

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

what is the…epistemic status, for lack of a better way to put it, of the probabilities? what do they mean? what (probabilistic) guarantees do we have about, say, the responses to

- 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?

The technology and the results are very handwavy. What is RLCD exactly ? What are scores on benchmarks compared to LLMs ?

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.

1. yes a general model 2. no training at all 3. but it is focused on "System 1" tasks (more human judgment, less math reasoning)

It's very generalized. Can't wait until everyone can see it.

Doom demo is beyond impressive, even scary

this might finally be smart enough and fast enough for jarvis. hard to feel like iron man when your assistant takes 8 seconds to decide to pause your music

The eval is baffling me

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.

Hm, would be good to understand the architecture better. Is this answering just from a world model informed prior? How informed is it by the information in the prompt? I can't see this maintaining calibration across all domains and all types of structured output.

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

There's a whole lot of information on this page that doesn't tell me anything about what this actually is. Can anyone spell out what the architecture is here?

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?

Funny how the authors are asserting that "doing the right task > data > compute > algorithms" while simultaneously releasing AI model for calibrated decision making, which if they work, would mean that "compute > doing the right task"

This, combined with contracts, could make a lot of things so much fun now!

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.

This will be insane for tool usage, and probably where the major economics for day-to-day usage will be.

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

This makes me think of Expressions of Change [1], a project that aimed to make updates to a program a first-class primitive in a programming language. A model like this can't output code directly, but perhaps it would be well suited to select from the small set of discrete operations on code envisioned by the EoC author?

[1]: www.expressionsofchange.org

Hasn't there been a lot talk about Astra's opaque reasoning capabilities (being able to think through complex questions without using a chain of thought)?

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)

This has the potential to be huge for computer use.

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.

This is amazing. I really could use this.

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.