TypeSafe AI and the Jev Model: The Company Building System One AI
The TypeSafe AI Jev model functions as machine-native decision infrastructure rather than a traditional conversational interface. Developed for real-time software loops, this flagship product is designed to execute fast, reliable evaluations where conversational nuance is unnecessary, and developers can try jev to integrate it into their automation pipelines. TypeSafe AI released Jev in limited early access on September 15, 2026 as its first System One model. The technology returns typed, probabilistic decisions for applications to process directly, skipping the natural-language generation entirely.
Engineered to operate inside games, robotic controllers, and agent guardrails, the architecture focuses exclusively on speed and strict type adherence. TypeSafe claims this approach operates dramatically faster and significantly cheaper than frontier large language models, completely eliminating the possibility of hallucination. Input costs remain exceptionally low, while output tokens are provided entirely free of charge.
This guide examines the core functionality of the system, detailing the foundational primitives, specific deployment methods, the underlying pricing structure, and the recent financial backing that propelled the company out of stealth mode.
What is TypeSafe AI and what is Jev?
TypeSafe AI is a San Francisco AI lab building machine-native decision infrastructure, and Jev is its flagship model — the first System One model that returns typed probabilistic decisions instead of text. TypeSafe AI developed the Jev model to prioritize machine-to-machine interactions over human-readable text generation. Jev is the first System One model designed strictly for deterministic software environments. Because Jev outputs typed probabilistic decisions instead of text, it avoids the unpredictability inherent in autoregressive generation.
TypeSafe AI in one sentence
TypeSafe AI operates as a specialized artificial intelligence laboratory focused entirely on machine-native intelligence infrastructure for automation. Founded in 2024 and based in San Francisco, the startup remained in stealth mode for approximately two years while refining its core technology. The company recently came out of stealth, introducing a fundamentally different approach to artificial intelligence deployment.
The laboratory’s driving philosophy centers on the tagline “Decisions, not strings,” highlighting their commitment to AI meant to make decisions inside software rather than chat with humans. By stripping away the conversational capabilities required by traditional chatbots, TypeSafe AI developed a streamlined architecture tailored for rigid computational demands. The engineering team focuses on creating tools that integrate directly into existing codebases without requiring complex parsing logic.
Jev in one sentence
Jev functions as the flagship product of TypeSafe AI, ingesting unstructured state data to produce strictly typed probabilistic decisions accompanied by precise confidence scores. The model is intentionally designed to be consumed by other software systems, completely bypassing the need to be read by a person. When an application queries the system, it receives structured outputs that map directly to predefined data types and programming logic.
The architecture supports several key operational characteristics:
- It receives unstructured context and programmatic questions simultaneously.
- It evaluates all provided questions independently during a single execution.
- It attaches a calibrated confidence score to every single response.
- It mathematically guarantees that all returned values adhere to the requested schema.
Who founded TypeSafe AI?
TypeSafe AI was founded in 2024 by Diogo Almeida, a former OpenAI researcher, together with Erik Gafni and Sasha Sheng. Diogo Almeida co-founded and leads TypeSafe AI, bringing extensive experience in large-scale model training and reinforcement learning. The leadership team established the company in San Francisco, recognizing the need for models optimized specifically for programmatic consumption rather than human dialogue.
Almeida serves as the Chief Executive Officer, leveraging his substantial pedigree from approximately four years of research at OpenAI. During his tenure there, his work heavily focused on Reinforcement Learning from Human Feedback (RLHF), contributing directly to the development of InstructGPT, ChatGPT and GPT-4. This deep understanding of conversational model limitations drove the vision for a strictly machine-native alternative.
To achieve this specialized behavior, the founders implemented a unique training methodology for their flagship product:
- Jev was trained on synthetic data using Reinforcement Learning from Calibrated Decisions.
- The model was co-founded by ex-OpenAI researcher Diogo Almeida to specifically avoid text generation.
- The engineering process prioritized mathematical probability calibration over conversational fluency.
The company operated quietly in stealth mode for roughly two years before its public debut. This extended development period allowed the team, guided by Almeida, Gafni, and Sheng, to perfect the underlying technology. By the time the laboratory launched its product, the founders had successfully engineered a system fundamentally distinct from the language models dominating the artificial intelligence industry.
What is a System One model versus an LLM?
A System One model outputs decisions directly as typed values, probabilities and confidence scores in one parallel pass, unlike an LLM that autoregressively predicts text token by token. Because Jev is the first System One model on the market, it fundamentally alters how developers approach artificial intelligence integration. Jev outputs typed probabilistic decisions instead of text, entirely removing the parsing overhead required when dealing with conversational agents.
System 1 vs System 2 thinking
The architectural naming convention draws a direct analogy to human cognitive processes described in behavioral economics. Traditional language models operate similarly to “System 2” thinking, functioning as step-by-step reasoners that slowly deliberate over complex problems. In contrast, the Jev architecture mirrors “System 1” cognition, providing fast, intuitive judgments that yield immediate conclusions without sequential deliberation.
This fundamental difference manifests in how applications interact with the respective technologies. While conversational agents excel at drafting emails or writing essays, they struggle with rigid software loops requiring instant, structured classifications.
| Dimension | Large Language Model | Jev System One |
|---|---|---|
| Output Format | Natural language text | Typed probabilistic decisions |
| Generation Method | Sequential tokens | Single parallel pass |
| Hallucination Risk | Always possible | Mathematically impossible |
| Average Latency | 3 to 329 seconds | 70 to 500 milliseconds |
Non-autoregressive by design
Unlike frontier large language models that produce strings one token at a time, this architecture takes a provided program state and returns a complete set of decisions simultaneously. Autoregressive models must predict the next word based on all previous words, causing response times to scale linearly with the length of the requested answer. The non-autoregressive nature of this technology eliminates this bottleneck entirely.
This parallel execution means adding more questions barely changes the overall latency of the request. The system evaluates every query independently against the provided state, returning all requested values in a single computational pass. Furthermore, this isolated evaluation strategy completely avoids context-rot, ensuring that early decisions do not negatively influence the accuracy of subsequent evaluations within the same payload.
How does Jev work: inputs, outputs and primitives
Jev takes a block of state plus typed questions and returns typed values with probability distributions and confidence, using three primitives — Choice, Score and Noul. The API infrastructure ensures Jev supports Choice, Score and Noul question types natively, allowing developers to map complex evaluations to simple data structures. Because Jev outputs typed probabilistic decisions instead of text, the resulting payload integrates seamlessly into strict software environments.
State in, decisions out
The operational flow begins by submitting a block of state to the API endpoint. This input state provides the necessary context for the evaluation and can be formatted as a raw text string, a structured JSON object, or a comprehensive text array. Alongside this state, the developer submits one or more typed questions that dictate the exact decisions the model needs to render.
When processing the request, the architecture evaluates each submitted question against the state in parallel and completely independently. The model does not attempt to construct a narrative or explain its reasoning; it simply calculates the probability of each potential answer.
To properly integrate the system, developers typically follow a strict sequential workflow:
- Define the relevant application state as a text block or JSON object.
- Formulate atomic, typed questions using the supported primitives.
- Submit the combined payload to the API endpoint.
- Receive the calculated decisions, complete with probability distributions.
- Extract the calibrated confidence scores for each answer.
- Execute programmatic logic based on the returned values.
The three primitives
The architecture limits developer interactions strictly to three highly optimized primitives, enforcing rigid type adherence across all queries.
- Choice evaluates the state and picks from a defined list, returning the selected choice alongside detailed probabilities and a confidence score.
- Score forces the model to rate the state against ordered levels, returning a specific score, associated probabilities, and a confidence metric.
- Noul requires the model to evaluate a yes or no statement, returning the result strictly as a 0 to 1 probability.
Engineers strongly advise decomposing complex judgments into these atomic questions rather than asking multifaceted queries. By breaking complicated evaluations down into individual Choice, Score, and Noul primitives, developers can combine the resulting structured outputs directly within their application code.
Why can’t Jev hallucinate?
Jev cannot hallucinate or produce type errors because its answers are constrained to predefined typed options, so every output is a valid value with a calibrated probability. By strictly enforcing these constraints, Jev cannot hallucinate or produce type errors under any operational circumstances. Because Jev outputs typed probabilistic decisions instead of text, the fundamental mechanisms that cause generative models to invent facts are completely bypassed.
Type safety as a guarantee
The impossibility of hallucination stems directly from how the system handles the provided schema. Because the possible answers are completely predefined by the developer’s question schema, the model mathematically cannot return an invalid or out-of-type value. The architecture never generates novel sequences of characters; it exclusively assigns statistical weights to the finite set of options provided in the initial API request.
This strict operational constraint contrasts sharply with free-form language model text that frequently invents facts or breaks a required schema. Autoregressive text generators guess the next most likely token, meaning they can easily drift off-topic, produce malformed JSON, or confidently state incorrect information. By eliminating text generation entirely, this specialized architecture guarantees absolute type safety for every single API response.
Calibrated confidence for escalation
Beyond simple type safety, the model provides deep visibility into its own mathematical certainty. Each decision carries a mathematically calibrated confidence score, representing the model’s precise statistical certainty regarding its selected answer. This metric is not a generalized guess, but a highly tuned probability distribution derived directly from the evaluation of the provided state.
This calibrated confidence lets software systems set exact thresholds to automatically act on reliable results or seamlessly escalate uncertain cases to human review. If the confidence score for a critical Choice evaluation falls below a developer-defined threshold, the application code can instantly route the decision to a human operator, ensuring that edge cases are handled safely without halting the automated pipeline.
How fast is Jev and how much does it cost?
Jev responds in about 70–500ms and prices input at $0.042 per million tokens with free output, which TypeSafe frames as 40–200x faster and 40–400x cheaper than frontier LLMs. Benchmarking indicates Jev runs 40-200x faster than frontier LLMs, making it highly suitable for real-time application loops. Furthermore, Jev input tokens cost $0.042 per million with free output, significantly reducing the financial burden of massive programmatic evaluations.
Latency
The non-autoregressive architecture yields unprecedented speed advantages for classification and evaluation tasks. End-to-end response times consistently measure between 70 and 500 milliseconds, depending heavily on the complexity of the provided state and the total number of submitted questions. This parallel processing capability ensures that network overhead remains the primary factor in total round-trip time.
TypeSafe claims Jev is 40–200x faster and 40–400x cheaper than frontier LLMs, with peaks of 193.6x faster and 444.6x cheaper on its own workflows. This massive reduction in latency completely unlocks use cases that traditional models simply cannot support. When compared directly to conventional low-latency API models, the single-pass evaluation strategy consistently demonstrates superior throughput for rigid, programmatic queries.
Pricing
The financial model completely upends traditional token-based billing structures used by conversational artificial intelligence providers. Jev’s input tokens are priced at $0.042 per million tokens while output tokens are completely free of charge. The company often markets this input rate as $42 per billion tokens, highlighting the massive scale at which developers are expected to deploy the system.
| Metric | Cost per million tokens | Speed advantage | Cost advantage |
|---|---|---|---|
| Input Tokens | $0.042 | 40-200x faster | 40-400x cheaper |
| Output Tokens | $0.00 | Peak 193.6x faster | Peak 444.6x cheaper |
The decision to make output tokens free directly reflects the model’s non-autoregressive nature, as it does not expend computational resources generating lengthy text strings. The company specifically markets a significantly lower input price than Claude Fable 5.1, positioning itself aggressively against established enterprise solutions. While the company highlights peaks of 193.6x faster and 444.6x cheaper performance, developers should note the caveat that these specific benchmarks were built by TypeSafe itself using highly optimized internal workflows.
How to access and use Jev
Jev is available in limited early access launched September 15, 2026 through console.typesafe.ai, with sign-in or a waitlist and documentation at docs.typesafe.ai. Jev was released in early access on September 15, 2026, generating significant interest across the developer community. Because Jev was released in early access on September 15, 2026, the company continues to slowly onboard new users to ensure optimal API performance.
Getting in
Engineers looking to integrate the model must navigate a structured onboarding process designed to manage server load. The primary steps require users to join the waitlist or attempt a direct sign in at console.typesafe.ai. The platform officially launched its early access program on September 15, 2026, initially opening the doors to a highly curated selection of enterprise partners and specialized developers.
The initial launch generated immense curiosity regarding the non-autoregressive architecture and strict type safety guarantees. Note that the remarkably high launch demand caused temporary API outages as thousands of developers simultaneously attempted to benchmark the advertised latency metrics. The infrastructure team has since stabilized the platform, but access remains metered through the official console gateway.
Building a harness
Once granted access, software engineers must construct a specialized integration harness that fundamentally differs from conversational chat completions. Developers begin the workflow by defining their exact application state and structuring their precise typed questions using the supported Choice, Score, and Noul primitives. This payload is then serialized and transmitted securely to the main API endpoint.
Upon receiving the response payload, the application code must gracefully read back the strictly typed decisions. Crucially, the code must actively evaluate the provided confidence metric, utilizing programmatic logic to set strict action thresholds based on the model’s statistical certainty. Comprehensive guides covering this exact implementation workflow live permanently at docs.typesafe.ai, providing detailed code snippets for various programming languages.
What can Jev be used for?
Jev is used for real-time decision loops — classification, safety and command review, agent guardrails, model routing, and feature extraction — where software needs fast, reliable typed decisions. Whenever an application requires structured intelligence, Jev outputs typed probabilistic decisions instead of text to ensure seamless execution. Because Jev is the first System One model, its use cases inherently differ from conversational assistants.
Core use cases
The architecture thrives in environments where speed, cost, and absolute strictness outweigh the need for human-readable explanations.
- The model powers real-time loops in competitive games, advanced robotic controllers, and complex physics simulations.
- It excels at large-scale content classification and rapid feature extraction across massive datasets.
- Enterprise systems use it for the automated safety review of sensitive system commands.
- Corporate teams deploy it for rapid, high-volume business email classification.
- Security platforms utilize it for monitoring LLM agents to actively block jailbreaks.
- The system orchestrates highly efficient model routing decisions to lower total compute costs.
- The architecture acts as the primary layer for guardrailing unconstrained LLM outputs.
Early developer reactions
The initial wave of testers reported compelling results when migrating away from traditional text-based inference. Many developers integrating the technology into automated coding workflows noticed immediate improvements in pipeline stability.
The company cited several reported reactions from early enterprise adopters testing the infrastructure. Vercel’s Pranit Sharma saw results that were several times faster while simultaneously achieving much higher classification accuracy. Conversely, Bryo AI’s Nikhil Mudholkar found the system to be many times more expensive than basic Gemini tiers, but emphasized that it provided vastly superior, actionable confidence scores that justified the cost for critical operations.
Funding, investors and valuation
TypeSafe AI raised a $40 million seed round led by DCVC at a reported $200 million valuation, announced with Jev’s launch. In a massive display of market confidence, TypeSafe AI raised a $40 million seed round led by DCVC to aggressively scale its infrastructure. Furthermore, Jev was trained with Reinforcement Learning for Calibrated Decisions on synthetic data, a costly process supported by this heavy capitalization, and Jev is named after economist William Stanley Jevons to reflect its market philosophy.
The company secured a massive injection of capital immediately upon exiting stealth mode. State the $40 million seed round led by DCVC at a reported $200 million valuation, which instantly established the startup as a major competitor in the specialized infrastructure space. This significant financial backing, seed round led by DCVC), was formally announced alongside the September 15, 2026 launch, proving that institutional investors see massive potential in non-autoregressive architectures designed explicitly for software integration.
The engineering team required substantial compute resources to execute their novel training methodology. Jev was trained strictly on high-quality synthetic data via Reinforcement Learning from Calibrated Decisions. TypeSafe AI raised a $40 million seed round led by DCVC, at a reported $200 million valuation to fund this exact research, allowing them to perfect the statistical weighting necessary for their Choice, Score, and Noul primitives without relying on scraped human conversational data.
The branding of the flagship product directly reflects an economic theory regarding technological efficiency. The model is named after economist William Stanley Jevons and the well-known Jevons paradox. This paradox describes the idea that making a resource, or in this case, AI inference, dramatically cheaper and faster actually drives far wider deployment and overall consumption. By pushing latency down to 70 milliseconds and dropping prices significantly, the founders believe their technology will be embedded into billions of automated micro-decisions across the internet.
FAQ
When was Jev released?
TypeSafe AI released Jev in limited early access on September 15, 2026. It was introduced as the company’s first System One model.
Is Jev free to use?
Jev is not completely free, but its output tokens cost nothing. Users only pay for input tokens at a rate of $0.042 per million tokens.
Can Jev replace LLMs entirely?
No, Jev is not designed to replace general-purpose LLMs across every domain. It serves as a specialized, low-cost alternative for discrete decisions rather than open-ended text generation.
What are the main limitations of Jev?
Jev is restricted to structured decision tasks and calibrated outputs rather than open-ended dialogue. Tasks requiring continuous prose or conversational back-and-forth still require standard language models.
How was the Jev model trained?
Jev was trained on synthetic data using Reinforcement Learning from Calibrated Decisions. This training approach enables fast and deterministic outputs.
How much cheaper is Jev compared to traditional LLMs?
TypeSafe claims Jev is 40–400x cheaper than frontier LLMs, reaching up to 444.6x cheaper on its own workflows. This low expense is supported by free output tokens.