Jev becomes an infrastructure piece for those building agents in production

At the AI Engineer Code Summit, held this week and covered by Latent Space, the edition's central theme was what the industry has been calling "system one models": models that don't generate text, but instead return structured choices, scores, or probabilities, much faster and cheaper than a reasoning LLM (the so-called "system two"). The protagonist of the conversation was Jev, launched in September 2026 by TypeSafe AI, which, according to Latent Space's report, already sparked the year's most popular episode on the outlet's podcast when it was announced.

Diogo Almeida, CEO of TypeSafe AI and creator of Jev, took the stage for an almost evangelical speech. His central thesis is simple to state and hard to ignore for anyone building products with an LLM at the center: the problem isn't intelligence, it's reliability. He summed up the point with an analogy that was already circulating in the event's hallways.

You get Einstein 95% of the time, but Mr. Bean 5% of the time.

Diogo Almeida, CEO of TypeSafe AI and creator of Jev

The question he asked next is the one every agent engineer has already asked in production: if you can't predict which of the two will respond, how do you automate something with confidence? This is the vacuum that Jev promises to fill, not as a replacement for the LLM, but as a second piece on the decision line.

Integrating the fast model inside the code, not around it

The most relevant point of Almeida's keynote for system architects was the explicit argument that system one models need to live inside the application code, not as an isolated, generic API call.

Code is the language of automation, therefore you need to integrate with code.

Diogo Almeida, CEO of TypeSafe AI

swyx, founder of Latent Space, translated this idea into more practical terms for anyone who has already suffered with fragile prompt engineering.

Liberally sprinkle "System One" model calls everywhere INSIDE application code to make smarter software instead of increasingly convoluted forms of "concat strings together and hope for the best" AI engineering.

swyx, founder of Latent Space

In practice, this describes a specific architectural pattern: instead of a single LLM deciding everything via a giant prompt, the flow now has dozens of small decision points (ranking, classifying, scoring) resolved by a fast, cheap model, with the LLM reserved for what requires actual text generation or multi-step reasoning. It's a division of labor, not a replacement.

How Glean uses Jev alongside the LLM

Chinmay Goyal, from Glean, presented right after Almeida a more operational version of the same idea. At Glean, Jev coexists with LLMs and with traditional classifiers, each handling a different type of decision within the same product. The differentiator he highlighted is what's called "zero-shot flexibility": when the taxonomy of decision categories changes, there's no need to re-tune the model from scratch.

As the taxonomy of the decision space changes, we don't have to fine-tune these models again and again.

Chinmay Goyal, Glean

This tackles a real problem with classic classifiers: every time the product gains a new category, the traditional scoring model needs to be retrained. If Jev actually sustains this in production without quality loss, it's a concrete maintenance advantage, but the source doesn't bring accuracy numbers comparing the two approaches, so it's worth treating the claim as customer-reported, not as an independent benchmark.

Goyal was also direct about a product decision that many AI teams face: the end user doesn't need to, and shouldn't, know which model responded.

Jev powers a significant number of flows [but] the user just needs to have a product that works; that is always our aim with building anything. So we want to hide away all the complexity of whether we are using Jev or we are using a full-blown LLM.

Chinmay Goyal, Glean

In closing, Goyal said he had offered a list of practical rules on when to use Jev instead of an LLM, but the Latent Space material doesn't reproduce the content of those rules, only notes that they were presented. It's a gap worth pressing TypeSafe AI or Glean itself about before copying the pattern.

UiPath: a tournament of thousands of calls in under a second

The most concrete architecture example came from Chibi Vikram and Kevin Bernstein, from UiPath. They showed a document chunk ranking system organized as a tournament: Jev compares small groups of chunks, the winners advance to the next round, and so on until only the most relevant one remains. According to the pair, the entire process, with thousands of calls to Jev, runs in under a second.

Vikram summed up the architectural lesson directly: the isolated model isn't the end product, the composition strategy is.

We realized that Jev is a building block that we can adjust, and we have to find these new strategies where we will be able to apply this building block. It might look less intelligent on its own, but with these strategies and patterns, we can get more intelligent, with even the current Jev model that we have.

Chibi Vikram, UiPath

This is the kind of pattern that only makes economic sense with a fast, cheap model: running a tournament of thousands of comparisons via a reasoning LLM would cost latency and money incompatible with an interactive product. It's also the point where Almeida's promise becomes easiest to test: it's not about Jev being "intelligent" on its own, it's about the composition of many cheap calls outperforming one expensive, slow call.

Workday: predicting the action, not just the phrase

Scott Roberts, Principal Engineer at Workday, closed the session with a prototype that nicely illustrates the difference between generating text and predicting a structured choice: an interface that starts filling out a time-off form while the user is still typing, using Jev to anticipate the decision. Roberts described the shift directly: the software moves from predicting what the user will say to predicting what they will do.

This case points to a use of system one models that breaks from the "chatbot" pattern: it's not response generation, it's intent inference applied directly in the interface, in real time, without the user even noticing that a model call took place. It's a use that's only viable with millisecond latency, something a reasoning LLM can hardly deliver at scale.

What changes (and what doesn't) for those building agents

For teams already building agents in production, the practical takeaway that emerges from the event isn't "swap the LLM for Jev", it's redesigning the decision pipeline in layers: scoring, ranking, and classification become cheap and fast enough to run hundreds or thousands of times per request, while text generation, planning, and multi-step reasoning stay with the LLM. This changes the cost and latency math for patterns like context reranking for RAG, tool routing in agents, and output validation before exposing it to the user.

Healthy skepticism here has three concrete fronts:

• The numbers cited (thousands of calls in under a second, zero-shot without fine-tuning) come from customers reporting on stage, not from published, reproducible benchmarks;
• TypeSafe AI did not publicly detail, in the Latent Space material, how Jev is trained or what the per-call cost structure is outside the context of the case studies;
• "Smart software" is, still according to the coverage, a marketing term that echoes Web 2.0 jargon, and it's worth separating the discourse of total automation from the actual use, which in the three cases presented is far more modest and specific (ranking, autofill, routing).

Almeida's closing remarks comparing the moment to the explosion of the early internet are revealing of the stage the ecosystem is at: more exploration than consolidation.

I think that there's going to be an explosion of what software can do, and we will want people to be exploring those boundaries of software. Not necessarily because it's valuable, but because they can, because we have new frontiers to explore, and this is what the early internet was like.

Diogo Almeida, CEO of TypeSafe AI

For those deciding architecture today, the reasonable path is to treat Jev and the system one models category as one more tool in the decision pipeline, testable in parallel with traditional classifiers and existing LLM calls, not as an automatic replacement for either until there's a published independent benchmark.