Jev is TypeSafe’s AI model that makes structured decisions: it returns options, scores, and probabilities instead of generating text.
That difference proves useful when an agent needs to choose its next action. Clicking a button, routing a request, or deciding which tool result to keep doesn’t always require drafting a response. Sometimes, the application already knows the available options and needs help choosing.
Two projects illustrate this idea: a browser agent that separates action selection from text writing, and a compaction library that selects which parts of an agent’s history to keep. Both allow examining Jev’s role in concrete applications.
This article analyzes their published code and documentation. We have not run the projects or independently reproduced their performance results.
What is TypeSafe’s Jev and how does it work?
Jev evaluates an application’s state through questions with predefined response types. Your code provides the context and possible options; the model returns structured results.
TypeSafe offers three primitives:
| Primitive | Example Question | Result |
|---|---|---|
| Choice | Which team should handle this support request? | A selected option and a probability distribution across the options |
| Score | How urgent is this request on our scale? | A score based on an ordered scale of criteria |
| Noul | Does this request describe a service outage? | A value between zero and one representing the model’s evaluation |
These are conceptual examples, not SDK syntax. The primitives can share the same state in a single request. TypeSafe Documentation
Afterward, the application decides what to do with the result:
Application state → typed question → probabilities → application rules → action or review
That rules layer matters. The model determining that a request is about billing doesn’t verify who sent it, doesn’t grant account access, or authorize a refund.
How does a browser agent use Jev?
The Jev Ultrafast project presents Jev with an indexed set of browser controls and asks it to select an operation and element. When the operation requires text, another generative model writes it.
In the documented example, Jev decides where to type and Mercury provides the city names. The division of labor is explicit: selecting an action and producing text are separate tasks.
The code checks the selected element before executing the action. It also limits the model’s selection to observed controls. These checks help link the decision to the actual page, though they don’t guarantee that the chosen action brings the agent closer to the user’s goal.
The project supports common HTML and ARIA controls, with limitations on elements like frames, shadow roots, canvas, and file uploads. The code to run it locally is available; as of September 19, 2026, its cloud service has an independent waitlist. Browser Agent Repository
What does the seven-second flight search demonstrate?
The author reports a flight search completed in 7,073 seconds, up to displaying available options. No booking was made.
The timer starts after the initial page observation. It includes requests to the models, text generation, browser operations, and load waits. It excludes environment setup, initial navigation, and independent verification afterward.
Comparison between versions is especially important: both already used Jev and Mercury. Across three test pairs, the median dropped from 9,450 to 7,092 seconds after optimizing the execution code, a 25% reduction.
It’s a useful result for that specific workflow. It doesn’t establish how much faster Jev is than an agent based on a conventional LLM or how reliably it handles other websites.
The recorded execution used 17 requests to Jev and two calls to the auxiliary text model. The small amount reported for that auxiliary model is only part of the task’s cost. Published Performance Report
How does Jev help reduce an AI agent’s context?
The fast-jev-compaction project uses Jev to decide whether to keep, truncate, or remove tool calls and their results.
This differs from asking a model to rewrite the history as a summary. The retained content can remain literal, with its routes, errors, and exact commands.
However, that preservation only applies to what remains. If the system deletes needed evidence later, the resulting context has lost information.
There’s another important limit: the state Jev receives includes conversation text and tool inputs, but represents their results through brief metadata descriptions. Therefore, it doesn’t evaluate each result from its full content. Long histories can also require multiple requests that repeat the state.
The repository offers an npm library and an integration with Claude Code. As of September 19, 2026, its README indicates this integration depends on function hooks in early access. It’s worth treating it as an example subject to that condition, without assuming it works on any installation.
Its animated demo follows a script and doesn’t call the API: it provides no evidence about latency. Compaction Repository
Is Jev faster and cheaper than an LLM?
TypeSafe reports significant improvements in its own workflow evaluations: its highlighted figures reach 193.6 times faster and 444.6 times cheaper. These are provider results under specific comparison conditions.
The reference responses come from the average of predictions from other models, rather than from independently labeled correct answers. The comparison also requires LLMs to produce compatible structured decisions and probabilities, which adds work.
TypeSafe acknowledges those figures sit at the upper end of the improvements it expects. Its latency measurements were generally conducted near the service, on the US West Coast. Teams deploying applications in Latin America need to measure from their own regions.The practical question is whether Jev improves a concrete workflow with an acceptable error rate, accounting for network time, auxiliary models, retries, and fallback mechanisms. Announcement and methodology
Does a typed response guarantee a correct decision?
A typed response restricts the shape of the output. It does not prove that the selected option is correct.
TypeScript’s documentation describes difficulties with negations, arithmetic, date comparison, multi-step reasoning, and irrelevant context. It also warns that adversarial content included in the state can influence decisions. An allowed action may still be the wrong action. Documented model limitations
The confidence value requires the same care. In Choice and Score it is calculated from the concentration of the probability distribution returned. Noul does not expose that same property.
A confidence value of 0.9 should not be automatically interpreted as 90% accuracy independently verified. Thresholds should be evaluated with examples representative of your application. Confidence documentation
Keep exact arithmetic, permission checking, and authorization in deterministic code. Use the model for the part that requires judgment.
How much does Jev cost and what should you review before using it?
As of September 19, 2026, TypeSafe publishes a price for its direct service of $0.042 per million input tokens, with output tokens free.
The documented model accepts text, with a total limit of 64,000 tokens per request and another limit of 32,000 tokens for the state plus the longest question. TypeSafe indicates that English currently offers the highest accuracy, so use cases in Spanish require their own evaluation. Models, pricing, and limits
On that same date, the service is offered in early access. Official instructions exist to get started, but their publication does not guarantee that all readers can obtain immediate access. Official quickstart guide
Data handling is also part of the evaluation. TypeSafe states that it does not train on customer data and offers zero retention for enterprise customers. These are distinct commitments: the promise not to train does not imply zero retention by default. Data policies
Finally, application repositories being public does not prove that Jev’s weights are available or that you can host the model on your own infrastructure.
How to evaluate Jev in your own application?
Start with a bounded decision task and examples whose expected outcomes you can establish.
A useful evaluation should measure:
- Quality of decisions: correct answers, costly errors, and behavior when information is missing.
- Calibration: whether higher stated confidence corresponds to better observed results.
- Full latency: median and 95th percentile of the task time from your deployment region.
- Total cost: repeated state, auxiliary models, retries, and fallback mechanisms.
- Failure behavior: Spanish inputs, misleading context, and attempts to influence decisions through unreliable content.
Compare it with your current implementation and with deterministic rules when these can solve the task.
Jev offers an architecture option worth evaluating: reserve text generation for tasks that need it and use bounded decisions when your application already defines the possible outcomes. Its value depends on how that division works in your system and what checks your code applies before converting a decision into an action.