{"componentChunkName":"component---src-templates-blog-post-js","path":"/jev-means-structured-output-is-interesting-again/","result":{"data":{"site":{"siteMetadata":{"title":"sean goedecke"}},"markdownRemark":{"id":"0a94f647-5ace-5853-888b-9761616a2970","excerpt":"I don’t write blog posts about new models. That’s Simon Willison’s beat, and he’s very good at it. But I want to write about Jev, which is a different kind of…","html":"<p>I don’t write blog posts about new models. That’s <a href=\"https://simonwillison.net/\">Simon Willison’s</a> beat, and he’s very good at it. But I want to write about <a href=\"https://typesafe.ai/blog/introducing-system-one-models-and-jev\">Jev</a>, which is a different kind<sup id=\"fnref-1\"><a href=\"#fn-1\" class=\"footnote-ref\">1</a></sup> of AI model: a “System One”<sup id=\"fnref-2\"><a href=\"#fn-2\" class=\"footnote-ref\">2</a></sup> model. As it turns out, it’s not <em>that</em> different from an ordinary LLM with structured output, but the interface it uses is very cool and I hope it becomes more widespread.</p>\n<h3 id=\"how-jev-is-different-from-llms\" style=\"position:relative;\">How Jev is different from LLMs<a href=\"#how-jev-is-different-from-llms\" aria-label=\"how jev is different from llms permalink\" class=\"heading-anchor after\"><svg aria-hidden=\"true\" focusable=\"false\" height=\"16\" version=\"1.1\" viewBox=\"0 0 16 16\" width=\"16\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a></h3>\n<p>Ordinary LLMs take in some human-language prompt and produce some human-language output. They do so <em>autoregressively</em>: first they produce one token, then the next, then the next, and so on.</p>\n<div class=\"gatsby-highlight\" data-language=\"text\"><pre class=\"language-text\"><code class=\"language-text\">User: Who invented the sandwich?\nLLM: The sandwich was invented by the Earl of Sandwich.</code></pre></div>\n<p>This makes them extremely flexible, since they can do literally anything a computer can do. But it also makes them slow and weird. Slow, because they have to run a whole new generation pass per-token, and weird, because the space of human language is so broad that you can get <a href=\"https://community.openai.com/t/is-chatgpt-hacked-major-chinese-gambling-advertisements-websites-showing-up-in-output/1375128\">really odd behavior</a> from a model trained on it.</p>\n<p>Jev takes a human-language prompt, but it does not produce human-language output. It only produces structured output.</p>\n<div class=\"gatsby-highlight\" data-language=\"text\"><pre class=\"language-text\"><code class=\"language-text\">User: { state: \"What color is the sky?\", choices: [\"blue\", \"red\", \"yellow\"] }\nJev: { answer: \"blue\" }</code></pre></div>\n<p>So far, so ordinary: LLMs <a href=\"https://developers.openai.com/api/docs/guides/structured-outputs\">do this already</a>. But it turns out that if you build a model that <em>only</em> produces structured output, you get some interesting and desirable properties.</p>\n<h3 id=\"jev-is-consistently-fast\" style=\"position:relative;\">Jev is consistently fast<a href=\"#jev-is-consistently-fast\" aria-label=\"jev is consistently fast permalink\" class=\"heading-anchor after\"><svg aria-hidden=\"true\" focusable=\"false\" height=\"16\" version=\"1.1\" viewBox=\"0 0 16 16\" width=\"16\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a></h3>\n<p><strong>Jev is always really fast.</strong> The fastest response time is around 70ms instead of a couple of seconds for normal LLMs. Even better, the <em>slowest</em> response time is only 500ms. Because Jev only does structured output, it isn’t autoregressive: it can produce answers to many questions in parallel in a single forward pass. When a LLM is producing structured output, it has to produce the tokens ”{”, ” ”, “answer”, ”:”, and so on with successive forward passes<sup id=\"fnref-3\"><a href=\"#fn-3\" class=\"footnote-ref\">3</a></sup>. Jev does it all in one go.</p>\n<p>The most compelling example of Jev’s speed is that <strong>the model can play Doom</strong>. You can feed a text-based representation of the current game state into the model, combined with a set of choices like “should the trigger be held down”, “what should the current goal be”, “given that the current goal is X, what keyboard input should be pressed”, and so on, and it works — latency is low enough and the system is smart enough that the model plays well in real time.</p>\n<p><span\n      class=\"gatsby-resp-image-wrapper\"\n      style=\"position: relative; display: block; margin-left: auto; margin-right: auto; max-width: 590px; \"\n    >\n      <a\n    class=\"gatsby-resp-image-link\"\n    href=\"/static/d54381912237e0f153a14473f60d04e9/5bef7/doom.png\"\n    style=\"display: block\"\n    target=\"_blank\"\n    rel=\"noopener\"\n  >\n    <span\n    class=\"gatsby-resp-image-background-image\"\n    style=\"padding-bottom: 42.567567567567565%; position: relative; bottom: 0; left: 0; background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAJCAYAAAAywQxIAAAACXBIWXMAABYlAAAWJQFJUiTwAAAB90lEQVQoz0WS207bQBRFnYDj+3jsGOPETjGB2AlJSGighJaL2qpFQkiFSn2oUF/6//+wemyQamnpnBmPtvf2GaPnBuz2/DcUO6YWIkwzptdLiL0S7R1i2Sm23ewpTDlr2h5WEGC5Un1ZSzUdF8P0TFTkkmR9BkWf6UQLEbXU6igkK0KSYYwb2pjeLk7s4EjvBBaOsnEbQgc3kn3tYMhDqBX7WUp9fMTlouDTKufurOBieUB5MCIfpFimidHp4GcKNY5QZUTwTuPLB/0saIWdQAQ7OwaLIqXSPsq3iXUoKJJYCyHvxN1qNiIOPTlsoPIQPU2EPcI6adFVgp/64lIid0Xw63zM06Jmu6l4uN3w7XrN549n3Jyf8F36xy8XDNO4iUMwDIlme0Rz4aSpKeFhhJd4El0EO12D00nJ1XrOYl5xtaxZVAfyD0tOpsfMphNms5pABtA6HGn62xwtok2vSmEksfe8N4fdDpN6wnK1ZL1e8f58wyDtc7eZcn1zzXK5YLU+JU3T1qEqdBs5HMdt/GAQiGv1Ktg47Fo97lenPF9d8mf7gZdfP3m4W/P3/lbWW348P/Hy+5HDcvgaOQ1aEX/oC/+r13dlMCIYZx6TKmc8zhnsJ2R5xkiuT56nDDJZF5m8y9CxOPAtPInVRGuvSovb4rRTdvkHc6zmr9bvEZ0AAAAASUVORK5CYII='); background-size: cover; display: block;\"\n  ></span>\n  <img\n        class=\"gatsby-resp-image-image\"\n        alt=\"doom\"\n        title=\"doom\"\n        src=\"/static/d54381912237e0f153a14473f60d04e9/fcda8/doom.png\"\n        srcset=\"/static/d54381912237e0f153a14473f60d04e9/12f09/doom.png 148w,\n/static/d54381912237e0f153a14473f60d04e9/e4a3f/doom.png 295w,\n/static/d54381912237e0f153a14473f60d04e9/fcda8/doom.png 590w,\n/static/d54381912237e0f153a14473f60d04e9/efc66/doom.png 885w,\n/static/d54381912237e0f153a14473f60d04e9/c83ae/doom.png 1180w,\n/static/d54381912237e0f153a14473f60d04e9/5bef7/doom.png 2746w\"\n        sizes=\"(max-width: 590px) 100vw, 590px\"\n        style=\"width:100%;height:100%;margin:0;vertical-align:middle;position:absolute;top:0;left:0;\"\n        loading=\"lazy\"\n      />\n  </a>\n    </span></p>\n<p>Of course you could train a neural net to play Doom already. But Jev is a <em>general</em> intelligence: just like LLMs can do your taxes, perform mathematics research, fix your Python environment, and write you a poem, Jev can do many other tasks besides playing a single video game. Current LLMs can play Doom too (albeit slowly). But as Nelson Elhage <a href=\"https://blog.nelhage.com/post/reflections-on-performance/#performance-changes-how-users-use-software\">famously said</a>, fast software doesn’t just mean we can do the same tasks faster, it means we can do entirely new kinds of tasks. What kinds of new programs can we write by injecting 100ms worth of dirt-cheap intelligence at various decision points?</p>\n<p>To me, this is the most exciting thing about Jev. <em>Fast</em> structured output could be a genuinely new computational primitive for intelligence. So far we’ve built a lot of programs on top of autoregressive token generation, and they all look like fancy chatbots. Leaning hard into structured output might conceivably unlock a bunch of non-chatbot use cases for AI.</p>\n<h3 id=\"structured-output-can-already-be-fast\" style=\"position:relative;\">Structured output can already be fast<a href=\"#structured-output-can-already-be-fast\" aria-label=\"structured output can already be fast permalink\" class=\"heading-anchor after\"><svg aria-hidden=\"true\" focusable=\"false\" height=\"16\" version=\"1.1\" viewBox=\"0 0 16 16\" width=\"16\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a></h3>\n<p>My biggest problem with Jev is that I think <strong>fast structured output is already available</strong>. Structured output from LLMs is only slow because (a) nobody really cares about it<sup id=\"fnref-4\"><a href=\"#fn-4\" class=\"footnote-ref\">4</a></sup>, and (b) the people who do care about it want big JSON blobs, so it’s typically implemented with <a href=\"https://www.aidancooper.co.uk/constrained-decoding/\">“grammar-constrained decoding”</a>: the LLM outputs autoregressively as normal, but the logit sampler discards tokens that don’t fit the structured output (e.g. if there hasn’t been a ”[”, you can’t output a ”]”).</p>\n<p>If you want fast, parallelized structured output against limited choices, you don’t strictly need to do autoregressive generation at all. You can simply prefill the response with <code class=\"language-text\">\"choice\": \"</code> and generate one token<sup id=\"fnref-5\"><a href=\"#fn-5\" class=\"footnote-ref\">5</a></sup>, restricted to the user-provided choices. Since LLMs ingest all input tokens in parallel, this is way faster than generating the entire structured output. Multiple choices can be batched into the same forward pass via ordinary inference batching. This doesn’t let you do long-form structured output, but in return you get most of<sup id=\"fnref-6\"><a href=\"#fn-6\" class=\"footnote-ref\">6</a></sup> Jev’s “secret sauce”: the speed, the consistency, and the parallelism of a System One model.</p>\n<p>People have <a href=\"https://x.com/harshagundal/status/2100044305536889015?s=20\">already started trying this</a> after today’s Jev announcement, and it seems like it’s working OK<sup id=\"fnref-7\"><a href=\"#fn-7\" class=\"footnote-ref\">7</a></sup>. In other words, I suspect Jev does not have a substantial technical moat, and their claimed “Reinforcement Learning for Calibrated Decisions” is not a brand-new scaling axis. It will probably be pretty easy for any other lab to replicate, or for individual programmers to retrofit existing open-source LLMs into a fast Jev-like model.</p>\n<p>However, I suspect Jev is still going to be better than most versions of “Qwen-32B-System-One” or whatever. Being able to fine-tune or optimize the model on just structured output is probably a meaningful advantage.</p>\n<h3 id=\"intelligence-and-hallucinations\" style=\"position:relative;\">Intelligence and hallucinations<a href=\"#intelligence-and-hallucinations\" aria-label=\"intelligence and hallucinations permalink\" class=\"heading-anchor after\"><svg aria-hidden=\"true\" focusable=\"false\" height=\"16\" version=\"1.1\" viewBox=\"0 0 16 16\" width=\"16\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a></h3>\n<p>I doubt Jev is ever going to be as smart as frontier LLMs. Not being able to use test-time compute at all<sup id=\"fnref-8\"><a href=\"#fn-8\" class=\"footnote-ref\">8</a></sup> is a big disadvantage, and will likely cap this kind of model around the strength of non-reasoning LLMs. In practice this shouldn’t matter too much for low-latency applications, but you shouldn’t see this as a new scaling axis or a way to produce more intelligent models.</p>\n<p>Jev’s developers claim it is immune from hallucinations. To me, this seems like a semantic dodge, since Jev can absolutely still pick the wrong choice (e.g. calling the sky “red”). I suppose that’s technically just a <em>mistake</em>, since the model is picking a user-provided choice instead of inventing something new out of whole cloth. Still, all of this is also true about regular LLMs with structured outputs, and it doesn’t make Jev any more reliable in practice.</p>\n<h3 id=\"conclusion\" style=\"position:relative;\">Conclusion<a href=\"#conclusion\" aria-label=\"conclusion permalink\" class=\"heading-anchor after\"><svg aria-hidden=\"true\" focusable=\"false\" height=\"16\" version=\"1.1\" viewBox=\"0 0 16 16\" width=\"16\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a></h3>\n<p>It’s unclear to me how much of Jev’s value is in the model itself, compared to the inference strategy of only generating one token per question. The data and demos in the announcement look to me like they could have been generated by plugging any Terra-sized model into a single-token inference stack. However, the people involved are credible, and I’m sure the model is good — I just wish they’d provided some comparisons that didn’t force the LLM to unnecessarily produce a blob of JSON token-by-token.</p>\n<p>Overall, I am happy that Jev exists and I hope it succeeds. I hope we do see some real competition in the fast-structured-output space, and that it motivates the big labs to release official versions of their own models that are fine-tuned for this. GPT-5.6-Terra-System-One would be a very interesting model to build AI products on top of.</p>\n<div class=\"footnotes\">\n<hr>\n<ol>\n<li id=\"fn-1\">\n<p>I did write about Thinking Machines’ <a href=\"/interaction-models/\">“interaction models”</a>, which are also a fast-enough-to-be-meaningfully-different paradigm for AI inference.</p>\n<a href=\"#fnref-1\" class=\"footnote-backref\">↩</a>\n</li>\n<li id=\"fn-2\">\n<p>They call Jev a “System One” LLM, after Daniel Kahneman’s <a href=\"https://www.gilesd-j.com/2023/03/30/reproducibility-thinking-fast-and-slow/\">partially discredited</a> <em>Thinking Fast and Slow</em>, where he divides human cognition into a lightning-fast System One and a slow-and-reflective System Two.</p>\n<a href=\"#fnref-2\" class=\"footnote-backref\">↩</a>\n</li>\n<li id=\"fn-3\">\n<p>If you’re thinking “wait, couldn’t you just aggressively prefill a regular LLM and only produce one constrained token”, keep reading.</p>\n<a href=\"#fnref-3\" class=\"footnote-backref\">↩</a>\n</li>\n<li id=\"fn-4\">\n<p>Not counting tool calls, which are built-in in a way that structured output isn’t.</p>\n<a href=\"#fnref-4\" class=\"footnote-backref\">↩</a>\n</li>\n<li id=\"fn-5\">\n<p>What if some of the user’s choices are longer than a single token? I haven’t tried this myself, but I’m sure you could translate them into a single token, or train the model to output “1/2/3” under the hood instead of the choice content, or generate only the first token of the choice if it’s different, or some other clever trick I haven’t thought of.</p>\n<a href=\"#fnref-5\" class=\"footnote-backref\">↩</a>\n</li>\n<li id=\"fn-6\">\n<p>Jev claims that their generated probabilities are “calibrated”, but I haven’t seen anything to suggest that these aren’t just regular logit probabilities. Maybe there’s some clever training they do to encourage accurate logprobs in uncertain situations (e.g. getting the model to produce <code class=\"language-text\">heads: 50, tails: 50</code> when predicting a coinflip, etc)? If so, I wish they’d written more about that in the announcement.</p>\n<a href=\"#fnref-6\" class=\"footnote-backref\">↩</a>\n</li>\n<li id=\"fn-7\">\n<p>I tried it myself with <code class=\"language-text\">Qwen2.5-1.5B-Instruct</code> and got a 2x-3x speedup compared to non-prefixed structured output.</p>\n<a href=\"#fnref-7\" class=\"footnote-backref\">↩</a>\n</li>\n<li id=\"fn-8\">\n<p>I suppose they could do some looped-transformer thing where they loop some fixed amount of times, but anything that looks like reasoning would make the model latency slow and unpredictable, defeating the entire purpose.</p>\n<a href=\"#fnref-8\" class=\"footnote-backref\">↩</a>\n</li>\n</ol>\n</div>","fields":{"discussionLinks":[]},"frontmatter":{"title":"Jev means structured output is interesting again","description":null,"date":"September 16, 2026","tags":["ai"]}}},"pageContext":{"slug":"/jev-means-structured-output-is-interesting-again/","previous":{"slug":"/tell-agents-the-why/","title":"Tell agents the why, not just the how"},"next":null,"preview":{"slug":"/tell-agents-the-why/","title":"Tell agents the why, not just the how","snippetHtml":"<p>Early AI agents were basically enthusiastic idiots. Working with them required you to tell them precisely what you wanted them to do (for instance, “method A exists on class B, please add an equivalent method to classes C through F”). Otherwise they’d go off and do entirely the wrong thing. But as AI agents have improved, this has changed.</p><p>When frontier models go off and do the wrong thing today, they don’t do it because they’re confused, they do it because they make an incorrect assumption about your goals or priorities. For instance, when GPT-6-Astra thinks it’s writing code for itself, it will produce <a href=\"https://lucumr.pocoo.org/2026/9/7/astra-why/\">minified code</a>. It’s perfectly capable of writing human-readable code — at least in Golang, where I’ve produced several thousand lines of acceptable code with the model — but you have to tell it that humans will be reading the code.<br /><a href=\"/tell-agents-the-why/\">Continue reading...</a></p>"}}},"staticQueryHashes":["1146911855","3764592887"]}