The Jev model arrived after two years in stealth, and the person behind it is far from an unknown name in the artificial intelligence world.
Diogo Almeida, co-inventor of ChatGPT and OpenAI veteran, founded TypeSafe with a very specific goal: to create a model that does not chat, does not generate text, and does not try to mimic a human typing on the other side of the screen.
The purpose is something else entirely.
Jev was built to make decisions inside real systems, directly in code, with speed and structure that large conversational language models simply cannot deliver.
If you have ever tried to fit an LLM into an automated production workflow, you know exactly the kind of headache that shows up: outputs in the wrong format, hallucinations in fields that need to be precise, latency too high for real-time decisions, and costs that scale fast.
That is exactly the problem that Jev’s programmatic logic with probabilistic decision-making aims to solve, and the first tests are showing results that really stand out.
Developer access is already open, and what this technology promises to change for anyone working with AI in production systems goes way beyond a simple model update. 🚀
Receive the best innovation content in your email.
All the news, tips, trends, and resources you're looking for, delivered to your inbox.
By subscribing to the newsletter, you agree to receive communications from Método Viral. We are committed to always protecting and respecting your privacy.
What makes Jev different from any LLM you have ever used
Most language models dominating the market today were designed to chat. They were trained to produce fluid, contextualized, and coherent text, which is great when you want a virtual assistant or a writing tool. But when the goal is to integrate artificial intelligence inside a real software system, with typed inputs and outputs, conditional flows, and performance requirements, that profile starts creating friction that is not easy to work around. The Jev model was built from a completely different premise: it is not a conversational language model, it is a System One Model designed to operate inside code, respecting data contracts and delivering predictable, structured, and fast outputs.
The big breakthrough here is that Jev completely abandons text and string generation. While traditional models generate tokens autoregressively, meaning one word after another in sequence, Jev takes an unstructured state as input and returns structured, typed values in a single parallel query. Diogo Almeida himself sums up the idea well when he describes the model as a frontier intelligence function call: an unstructured state goes in, a typed probabilistic decision comes out. Simple to understand, but with massive implications for system architecture.
While a conventional LLM receives a free-text prompt and returns free text, Jev operates with defined types, which means its output is already in the format your system expects, without parsing layers, without extra validations, and without the risk of an unexpected response breaking the entire application flow. This structural constraint limits outputs to predefined schemas, eliminating the parsing pipelines and guardrail wrappers that are typically required when you put a large language model to work inside business automation flows. For engineering teams working with process automation, data pipelines, or decision systems at scale, this is not a minor detail, it is a fundamental shift in how AI fits into product architecture.
The training methodology behind Jev
One of the most interesting aspects of Jev lies in how it was trained. TypeSafe built the platform around an alternative methodology called Reinforcement Learning for Calibrated Decisions, or RLCD for short. And a quick comparison helps explain why this matters so much.
Conventional frontier models are trained through Reinforcement Learning with Human Feedback (RLHF) or Reinforcement Learning with Verifiable Rewards (RLVR). The first one aims to satisfy human preferences in conversations, while the second tries to meet isolated programmatic verifications. The problem is that neither of these methods was designed to calibrate decisions inside production code.
Jev, on the other hand, is trained to produce calibrated probabilities over execution logic. In practice, this means that when the model returns a confidence score, that number has a direct correlation with the actual accuracy of the output. In other words, when Jev says it is 80% confident in a decision, that value genuinely reflects the chance of being correct, which is pure gold for anyone who needs to build reliable and auditable systems.
Parallel sampling and what it changes in practice
One of the most talked-about features in the first tests with Jev is parallel sampling, and understanding what it does helps a lot to visualize why this matters in production environments. Instead of generating sequential text tokens, Jev relies on a hardware-aware parallel sampler that evaluates and delivers all structured values simultaneously. This greatly increases model reliability in contexts where mistakes carry a high cost, such as risk classification, sensitive data triage, or automated decision-making in financial and operational workflows.
The internal sampler can handle high-cardinality selections, reaching up to 255 discrete options, using a two-stage process that scores each option independently before making the final choice. This design prevents the model from getting lost in complex decisions with many possible alternatives, something that tends to be a nightmare for conversational models.
In practice, parallel sampling works like an extra layer of internal verification, but without the overhead you would expect. TypeSafe was careful in designing the Jev architecture so that this process happens efficiently, keeping latency at acceptable levels even when multiple samples are being processed at the same time.
And the numbers are impressive. Internal evaluations conducted on the team’s West Coast servers recorded end-to-end response latencies between 70 and 500 milliseconds, a massive contrast with the 3 to 329 seconds observed in conversational frontier model deployments. In published flow evaluations, running on fixed computation graphs and measuring multi-step decision branching against GPT-6 Astra and Fable 5.1 consensus baselines, Jev was up to 193.6 times faster in execution.
The impact on cost per token
Performance is only half the story. The other side that catches attention is cost. Input processing is charged at $0.042 per million tokens, well below standard conversational rates, which range from $0.20 to $10 per million tokens. And because parallel sampling generates structured states without going through autoregressive token generations, TypeSafe delivers output tokens with no metering charge. For anyone operating at high volume, this cost difference can completely transform the economic viability of putting AI at the heart of a product.
From Doom to petabyte workflows: real-world tests
Talking about AI for production is easy, but delivering a model that actually performs well inside complex systems is a different story. And TypeSafe wanted to prove this with demonstrations that go well beyond the obvious. One of the most curious ones involved the classic Doom: engineers deployed a real-time reactive bot to operate on the game’s state structures, processing 10 queries per second, with an operational cost of approximately $7 per hour. Jev resolved branching rules in the middle of a fast-paced shooter’s chaos, showcasing its ability to handle conditional decisions at extremely high speed.
Another test, called Wikiracing, evaluated link selection in dense encyclopedia directories. Jev managed to complete traversals in fewer steps than external models without reasoning, precisely because it evaluated options without generating hallucinated dead ends. While other models got lost inventing paths that did not exist, Jev stayed focused on the routes that were actually viable.
Field tests confirm that the main target applications are real-time feature extraction, petabyte-scale data workflows, output verification layers, and automated branching logic, those scenarios where hand-written rules end up being fragile and hard to maintain. This is exactly the kind of problem that keeps anyone working with large-scale automation up at night.
Jev’s profile for real production systems
The Jev model was designed with a few characteristics that make immediate sense for engineers and system architects. The first one is native typing, which eliminates the need for serialization and deserialization layers between the model and the rest of the application. The second is output predictability, which drastically reduces the effort required for validation and monitoring in production. And the third is cost scalability, which according to TypeSafe behaves in a much more linear fashion than traditional conversational models, especially at high request volumes.
For anyone working with AI-based system architecture, one of the biggest challenges is not the model’s capability itself, but rather integrating that model into an ecosystem that has its own latency, format, and reliability constraints. Jev was designed to minimize exactly that friction, functioning as a first-class software component instead of an external service that needs to be queried, interpreted, and sanitized before it can be used. This shift in perspective has profound implications for how product and engineering teams think about AI adoption in their systems.
The programmatic logic embedded in Jev also opens the door for a different style of intelligent system development. Instead of trying to describe complex behaviors in natural language through prompts, developers can define decision contracts directly in code, specifying which variables go in, which outputs are expected, and which constraints need to be respected. The model then operates within those constraints, applying probabilistic decision-making only where there is room for legitimate variation.
This workflow is much closer to how engineers think about systems than how users interact with chatbots, and that is probably TypeSafe’s biggest bet with the Jev launch. The company has opened early access for developers and has already started onboarding engineering teams from its deployment waitlist. If Jev delivers in production what it promises in benchmarks, we are looking at a new category of AI tool, one that finally thinks like code instead of trying to imitate a conversation. 🎯
