# Jev: why your AI agents need a model built for decisions

Igor Kosolapov
https://kossolapov.com/en/blog/jev-typesafe-use-cases-guide

2026-09-22

Research · September 22, 2026

Nine use cases across browsers, agent context, search, spreadsheets, interfaces and evaluation. Understand TypeSafe’s technology, examine the evidence and build your first example.

Picture your agent’s working day. It receives a message, chooses a tool, inspects search results, decides what belongs in memory and checks its final answer. Much of this work consists of small decisions: where to send something, what to open, what matters and what can be discarded.

That is where TypeSafe AI’s Jev fits. Jevable showcases applications where these decisions happen quickly enough to change the experience itself. A spreadsheet interprets a row. An agent selects its next click. Search adapts to the task.

I reviewed official documentation, project source code and recent posts on X. This guide covers nine use cases, the underlying mechanism and a downloadable first experiment. We will start with the useful ideas, then build a concrete example around customer messages.

## What Jev is and where it belongs

The name is Jev. TypeSafe introduced it on September 15, 2026 as its first public System One model. Its job is to evaluate a situation and return decisions in a format that software can consume directly.

Suppose a customer says they were charged twice and wants the duplicate refunded. Your application needs a team, an urgency rating and a refund-request flag. Ask Jev for those specific judgments. Another model can draft the reply, ordinary code can calculate the amount, and a payment system can apply its own execution rules.

For a business owner, the useful part is the division of work. You can change how requests, documents or content are handled without turning every small branch into a long conversation with a general-purpose model. Start with a decision you repeat throughout the day that currently requires reading some text.

- [TypeSafe: introducing Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) — September 15, 2026 announcement. Vendor claims and benchmark qualifications.
- [TypeSafe: Introduction](https://docs.typesafe.ai/introduction) — The model contract: state, typed questions and independent decisions.

## Three ways to ask a question

Choice selects an option from your list, such as billing, technical, sales or unclear. You define what each option means. The response contains a selection and a probability distribution. We added unclear ourselves so our design can represent messages with insufficient information.

Score evaluates ordered descriptive levels. An urgency rubric might distinguish uninterrupted work, a problem with a workaround, and blocked work. The result can be fractional. It expresses a position on that rubric, not a number of hours or dollars lost.

Noul returns a value from 0 to 1 for a yes/no question, such as whether the customer explicitly requests money back. Do not discard that nuance too early: borderline cases are useful to review.

All three questions can refer to the same message in one request. Put the actual criteria in each question: an informative field name does not substitute for instructions.

![One message: Choice selects a team, Score rates urgency and Noul checks for a refund request; code applies the rules.](https://kossolapov.com/api/public/images/f99dcb20-23ab-4fcc-ab66-25f61b3e200b)
Conceptual diagram, not a result screenshot: shared state and three independent questions. Software executes the final action.

- [TypeSafe: Choice](https://docs.typesafe.ai/primitives/choice) — Selecting from predefined options.
- [TypeSafe: Score](https://docs.typesafe.ai/primitives/score) — Scoring against ordered descriptive criteria.
- [TypeSafe: Noul](https://docs.typesafe.ai/primitives/noul) — The probability of a yes answer to one question.
- [TypeSafe: HTTP API](https://docs.typesafe.ai/api) — Request and response fields, question types and errors.

## Why decisions can arrive quickly

In ordinary text generation, each token depends on earlier tokens. TypeSafe describes Jev as evaluating independent questions in parallel against shared state. Its training objective is called RLCD: reinforcement learning for calibrated decisions.

Consider an intake message. Topic, urgency and the presence of a complaint can be evaluated together, instead of making a separate request for each. But a question that needs the previous answer belongs in a later stage of your workflow.

This describes the public interface and the vendor’s stated approach. It does not reveal the complete network design, all training data or a parameter count we can responsibly invent. For implementation, the useful questions are which decisions can share a call, what data they require and how to check their results.

- [TypeSafe: RLCD](https://docs.typesafe.ai/introduction/machine-learning-primer) — What the vendor discloses about training objectives and calibration.
- [TypeSafe: Introduction](https://docs.typesafe.ai/introduction) — The model contract: state, typed questions and independent decisions.

## A valid answer can still be wrong

If only four teams are allowed, the model can return a perfectly valid team and still route the message incorrectly. A format guarantee does not prove that the situation was understood. Read the launch claim about hallucinations in the context of a constrained output schema.

Calibration concerns groups of decisions. For events assigned roughly 0.8 probability, we want about eight in ten to occur. An individual answer with that value can still be wrong.

Choice and Score also expose confidence, a summary of the probability distribution’s shape. It is not another name for the probability of correctness. Noul has no confidence field. Our example preserves both routing indicators and flags ambiguous rows for human review. Production thresholds need to be tuned on your own examples.

- [TypeSafe: Confidence](https://docs.typesafe.ai/confidence) — Why confidence and the probability of the selected answer are different.

## What Jevable actually demonstrates

Jevable collects projects and links to their original posts. It is a useful starting point for finding an author, a video and sometimes an open repository. A popular demonstration and a dependable product answer different questions.

For context, the gallery reports roughly 3.6 million views for context compaction, 3 million for the browser agent and 1.3 million for generative UI. These are its counter snapshots checked on September 20, not fresh view measurements from me. Separately, an Apify search on September 22 returned 76 posts from the preceding four days.

For each case below, I distinguish what the author shows, what source code establishes, what was measured and what we can adapt to our own work.

- [Jevable](https://jevable.com/) — Project and original-post directory. Gallery counters were checked by its curator on September 20.

## 01. Browser agents: selecting the next click

Browser Use’s Jev Ultrafast turns a page into a list of available actions. Jev selects an operation and target; code executes it and reads the page again. A separate LLM supplies free-form text. The implementation is public.

The published Zurich-to-London flight search took 7.073 seconds and involved 17 Jev requests. Browser startup and initial navigation are outside that figure. This is one specific task, not a promise for every website.

An adaptation could collect supplier offers or inspect your own form. Define completion in advance: the right page is open, filters are actually applied and the result is saved. A model saying “done” is not sufficient verification. Start with reading and navigation.

[Video demonstration](https://kossolapov.com/api/public/videos/1d412213-c361-4329-97f6-bfc9aced57dc)
Gregor Zunic’s original recording: the agent selects page elements and finds a Zürich → London flight. This is the creator’s run; the displayed figures are not an independent measurement by us.
[Original and creator](https://x.com/gregpr07/status/2100411066966749359)

- [Browser Use: Jev Ultrafast](https://github.com/browser-use/jev-ultrafast/tree/1231850a0bf1a0c0341fe408ef1668dbbfdfac46) — Pinned source. Jev selects actions; a separate LLM generates text.
- [Browser Use: measurements](https://github.com/browser-use/jev-ultrafast/blob/1231850a0bf1a0c0341fe408ef1668dbbfdfac46/docs/performance.md) — What the 7.073-second measurement includes, excludes and does not establish.
- [Browser Use: video](https://github.com/browser-use/jev-ultrafast/blob/1231850a0bf1a0c0341fe408ef1668dbbfdfac46/docs/demo.mp4) — Author video; this article is not an independent rerun.

## 02. Agent context: remove stale tool output

Tamara Tran’s fast-jev-compaction evaluates whether an old tool call still matters and whether its full result is needed. Code then keeps, truncates or removes the relevant record. Surviving text is not rewritten into a new summary.

The reviewed revision includes request-size budgets and batching, so “one request for the whole history” does not extend to conversations of arbitrary length. The original integration targets Claude Code; the idea alone does not make it a built-in Codex feature.

The benefit is a long task with less repetitive command output in context. Check more than token counts. Keep a copy of the history, then ask the agent to recover the original objective, constraints and latest error. Saving tokens is unhelpful if an important requirement disappears.

[Video demonstration](https://kossolapov.com/api/public/videos/869cc973-b047-4330-a66c-e3e4afaed470)
Tamara Tran’s demonstration of keeping or dropping tool results from context. This illustrates the compaction mechanism; the clip’s duration is not an API benchmark.
[Original and creator](https://x.com/tamarajtran/status/2100694549362553153)

- [Tamara Tran: fast-jev-compaction](https://github.com/tamaratran/fast-jev-compaction/tree/e3f262a7f4d42bd8dd32ced30d26176f7cb545b0) — README and keep / truncate / drop implementation reviewed.
- [Tamara Tran: original post](https://x.com/tamarajtran/status/2100694549362553153) — Original demonstration, also indexed by Jevable.

## 03. Search: choose sources and rank results

Search1API’s Jev Search separates retrieval from evaluation. A search service finds pages; Jev helps choose the search direction and assess the relevance of results. Users receive links and snippets rather than a generated answer of unclear provenance.

Its source contains distinct retrieval and ranking stages. A high relevance score does not establish that a page is true.

For competitor monitoring, first collect new pages, then score their relation to your product and send the useful ones to an agent for reading. Preserve the original URL and date. Ranking can shorten the queue; claims still need verification against the underlying content.

Another concrete example is Nader Dabit’s inbox search. In his demonstration, Jev helps filter messages by intent, such as refund requests expressed in different words. The video below shows that mail experiment; it complements Jev Search with a different interface for a related task.

[Video demonstration](https://kossolapov.com/api/public/videos/22293b78-e321-4014-9be6-a62e99cd23e0)
A separate intent-based search example by Nader Dabit: a mail interface filters messages by intent, such as refund requests. This video shows inbox search, not the Jev Search interface.
[Original and creator](https://x.com/dabit3/status/2100960281769738433)

- [Jev Search: source](https://github.com/superagents-lab/jev-search/tree/67027d0185a9b22eb2a178f0eb15250d12ddabe6) — README, pipeline and ranking code reviewed. Search1API performs retrieval.

## 04. Spreadsheets: add meaning to rows

In Nader Dabit’s demo, the Urgency column heading becomes an instruction to rate rows. The author shows a response around 100 milliseconds; that is his demonstration, not our measurement.

Imagine a sheet of customer messages. Someone normally reads each one and adds tags. Define an urgency rubric and a destination team instead, then use ordinary spreadsheet filters.

A useful instruction asks whether the customer’s work is blocked and whether a workaround exists. “Make this spreadsheet smarter” leaves too much unspecified. Keep revenue calculations in formulas. Jev adds semantic attributes; formulas do the arithmetic.

[Video demonstration](https://kossolapov.com/api/public/videos/50ef4fcb-a252-42e7-a4f6-3f59f23a9e6d)
Nader Dabit demonstrates how an Urgency column becomes a criterion for rating rows. The interface shows suggested values and controls to keep or undo the result.
[Original and creator](https://x.com/dabit3/status/2100780008193020049)

- [Nader Dabit: predictive spreadsheets](https://jevable.com/project/2100780008193020049) — Author demo with an original-post link; not an independent benchmark.

## 05. Interfaces: select suitable components

Chris Tate demonstrates json-render with Jev: an interface assembled from predefined components and actions. That is particularly interesting for forms and internal tools serving different user needs.

If someone asks to compare three plans, your application could select a comparison table. A request for a trend could select a chart. You prepared the available components, allowed parameters and action handlers in advance.

This can preserve a design system: the model chooses among your building blocks and the application renders them. The demonstration does not establish that Jev writes an entire frontend. Start with three components and ten requests, then check whether each selected view actually makes the data easier to understand.

[Video demonstration](https://kossolapov.com/api/public/videos/d6a7c97f-806b-4424-815b-08bbec4a5784)
Chris Tate’s experiment compares json-render UI construction with Jev and a conventional JSONL stream. This is a creator demonstration, not a universal benchmark for every interface.
[Original and creator](https://x.com/ctatedev/status/2101022101750571357)

- [Chris Tate: generative UI](https://jevable.com/project/2101022101750571357) — A json-render + Jev demo using predefined UI components.

## 06. Content and PR: filter the news stream

Elvis Sun reported screening 384 stories for 15 brands in 24.9 seconds for $0.19. His September 18 post had 651,439 views in our September 22 retrieval. Newsjack is open source; the figures remain author-reported rather than independently reproduced here.

For our editorial process, the adaptation is straightforward: ask whether each story fits the audience, supports a practical use case and has enough primary evidence. A writer or generative model then produces the article.

Begin with twenty stories and mark five genuinely useful ones yourself. Compare them with the system’s selection. If it repeatedly promotes hype without utility, improve the criteria rather than adding more feeds. Fast ranking does not replace editorial judgment.

[Video demonstration](https://kossolapov.com/api/public/videos/4b6e0248-5751-4fbc-9a02-2b040530c496)
Elvis Sun demonstrates News Desk Dealer: news items are matched to brands and scored for relevance. The time, cost and result counters belong to this specific creator run.
[Original and creator](https://x.com/elvissun/status/2100951347080421409)

- [Elvis Sun: news triage](https://x.com/elvissun/status/2100951347080421409) — September 18 post. Author-reported figures; retrieved with Apify on September 22.
- [Newsjack: source](https://github.com/elvisun/newsjack) — The author’s open project. Source availability does not validate every promotional claim.

## 07. Model routing: choose an appropriate executor

In Higgsfield’s demonstration, Jev selects a generative model for an image or video request. The chosen service generates the actual output.

The same design can route your own tasks: field extraction to a simple handler, difficult document analysis to a stronger model, and an unsupported format to a person. Describe each executor’s capabilities and include a no-suitable-option route.

A useful first experiment uses past tasks with a known good executor. Compare the router’s choices with those labels and calculate total cost, including failures and retries. A cheap first call is not a saving when the resulting work needs to be redone.

[Video demonstration](https://kossolapov.com/api/public/videos/c32fa14e-8f93-4ed3-bb8b-0d4f3db9f779)
Higgsfield demonstrates Jev selecting a model for a request, followed by that model generating an image or video. Jev does not generate the shown frames; its role here is routing.
[Original and creator](https://x.com/higgsfield_ai/status/2101022133753430365)

- [Higgsfield: model routing](https://jevable.com/project/2101022133753430365) — Author demo of selecting a generative model for a request.

## 08. Skill selection: narrow the list first

TypeSafe’s official cookbook selects from 182 Hermes skills. It first ranks the catalog, then examines three candidates more closely. It can also decide that no skill fits.

Across 488 requests, wrong skill loads fell from 16.8% to 7.3%. An important detail: the published experiment used Jev 1.12 and Claude Haiku 4.5, not the current Jev 1.13. These numbers describe that experiment, not every agent after installation.

For your team, start with a small catalog. Describe when each skill applies, what it does and which artifact it produces. Test similar requests that require different skills, such as creating a presentation versus editing an existing one. A router cannot compensate for indistinguishable descriptions.

A separate project by John Yeo shows the idea in an application: before the main Slack-agent run, Jev helps select the skill, tool and parameters. The video compares two runs side by side. This is a different experiment, so the Hermes cookbook figures above do not apply to this clip.

[Video demonstration](https://kossolapov.com/api/public/videos/dd9c9706-3487-4e80-b50a-e43fa7e99ee8)
John Yeo compares two Slack-agent runs, with and without Jev selecting the skill, tool and parameters beforehand. This is a separate project; the Hermes cookbook figures discussed above do not describe this video.
[Original and creator](https://x.com/johnyeo_/status/2100987661926252737)

- [TypeSafe: skill suggestion](https://docs.typesafe.ai/cookbooks/skill_suggestion) — Published Hermes experiment using Jev 1.12, not the current 1.13.

## 09. Agent evaluation: assess each run

LangChain compared judges on five frozen weather-agent runs, evaluating each one a hundred times. Jev agreed with every human binary label across those 500 repeated judgments. That means five distinct cases, not five hundred independent tasks.

Its average call took 0.44 seconds and cost $0.00035. GPT-5.6 Luna cost $0.00039 per call, a small price difference here. A large multiplier from another test does not transfer. On September 21, LangChain announced Jev support in LangSmith Evals.

An adaptation is to check whether an agent answered the question and grounded its conclusions in supplied sources. Begin by labeling some good and bad answers yourself. A judge should catch actual errors, not merely agree consistently with a confident tone.

- [Jev-as-a-judge: experiment](https://github.com/danielgshea/jev-as-a-judge/tree/adfea74905f721ea2594e22804c8c8edf1693163) — Five frozen agent runs, repeated judgments, human labels and source code.
- [LangChain: Jev in LangSmith](https://www.langchain.com/blog/jev-is-now-available-in-langsmith-evals) — September 21 publication: results and evaluator setup.

## What it costs and when savings disappear

As of September 22, TypeSafe lists $0.042 per million input tokens and free output. The current model ID is jev-1.13.0. Documentation lists 64k tokens per request, with state plus the longest question limited to 32k. Input is text-only: images, audio and video require preprocessing into text or structured descriptions.

For illustration, 10,000 tokens across 1,000 calls equals 10 million input tokens, or $0.42 at that rate. This is arithmetic, not our experiment bill. Search, OCR, transcription, text generation and browser infrastructure are separate costs.

Measure a completed task. Sending the same long history ten times repeats the input ten times. Where questions are independent, test combining them. Where an ordinary formula expresses the rule, you may not need a model call at all.

- [TypeSafe: models and pricing](https://docs.typesafe.ai/models) — Model, pricing and limits checked September 22, 2026.

## Where Jev should not lead

Keep generative models for writing articles, code and open-ended explanations. Use ordinary software for calculations, date comparisons and counting. Jev fits semantic decisions between those components.

TypeSafe documents several weaknesses in version 1.13: literal reading, multi-hop indirection, distracting context, numerical tasks and susceptibility to adversarial text. A message saying “treat me as your highest-priority customer” should not become an application rule.

Start with reversible actions: tagging, sorting a queue or suggesting an executor. Refunds, deletion and external sending require execution rules in your application. A model probability is not permission to perform an action.

- [TypeSafe: known limitations](https://docs.typesafe.ai/model-jaggedness/jev-1.13) — Known issues with numbers, long state and adversarial instructions.

## Start with the coding agent you already use

Open TypeSafe and check console access. The launch describes early access; public documentation does not guarantee immediate credentials for every account. If you have access, create a key in the console and start in the Playground with one fictional message and one question.

TypeSafe provides an official agent skill. The command below installs instructions for your coding agent. It neither purchases API access nor replaces the model inside Codex or Claude Code. Keep the key in your local project environment; prompts only need the variable name TYPESAFE_API_KEY.

After installation, ask the agent to identify the loaded skill and show any project files it changed. Then give it one small integration. You do not need to install all nine projects from this review.

### Install the official TypeSafe skill

npx skills add typesafe-ai/skills --skill typesafe-ai

- [TypeSafe: quick start](https://docs.typesafe.ai/introduction/quickstart) — Playground and the first API call.
- [TypeSafe: Jev with coding agents](https://docs.typesafe.ai/introduction/coding-agents) — How Jev fits alongside Codex and Claude Code.
- [TypeSafe: official agent skill](https://docs.typesafe.ai/agent-skill) — Official skill installation instructions.

## First project: triage five customer messages

I prepared a small companion kit: a CSV with five fictional messages and a Python script requiring no third-party libraries. It asks three questions per row: team, urgency and an explicit refund request. All fifteen questions share one request.

Start with dry-run. It writes request.json without sending anything. Inspect it: state should contain only the fictional messages, and questions should contain clear criteria. Before connecting real customer data, you can replace the examples with anonymized wording.

Provide your key locally, then run live separately. A successful response is saved to response.json, suggestions to review.csv, and model and timing details to run.json. The script does not update a CRM or send email. Invalid results stop execution instead of being filled with invented answers.

For this article, I verified request construction, processing of a synthetic response and rejection of invalid inputs. I did not make a live Jev call with this kit. The archive therefore contains no fabricated table of model predictions.

### Run from the extracted jev-starter folder

python3 jev_demo.py --dry-run --output first-preview

# After setting TYPESAFE_API_KEY in your local environment:
python3 jev_demo.py --live --output first-live

- [Download Jev Starter Kit](https://kossolapov.com/api/public/files/a68c644c-0bad-431f-b2ad-683c1e77426a) — ZIP · fictional CSV, Python example, 3 English prompts, RU/EN instructions and review log
- [TypeSafe: HTTP API](https://docs.typesafe.ai/api) — Request and response fields, question types and errors.
- [TypeSafe: state](https://docs.typesafe.ai/concepts/state) — How to prepare the data for a decision.

## A ready-to-use agent prompt

Download the kit, open it as a separate project folder and send this prompt to Codex or Claude Code. It deliberately begins with request inspection. If you already have a key and want a paid call, add: “Run one live evaluation now”.

Compare the resulting sheet with your own judgment. The examples cover a duplicate charge, blocked sign-in, a pricing question, a bug with a workaround and an ambiguous request. The last row is useful: the system needs a way to preserve uncertainty.

### Example prompt

Use the official TypeSafe skill to help me run the attached Jev starter project.
Read README-en.md and jev_demo.py first. Run the offline preview with the supplied fictional tickets, then explain the state, each question and the expected output files. Do not present dry-run data or synthetic test data as Jev predictions.
Use TYPESAFE_API_KEY from the local environment; never print it or put it in frontend code. If it is available and I request a live run, make the single request supported by the script and save the original response, review.csv and run.json. Otherwise tell me exactly how to configure access locally.
Check the selected teams against my manual labels. Show uncertain or incorrect rows, actual model ID, input-token usage and elapsed time. Keep all actions as suggestions: no messages, refunds or CRM updates. Reply in my language.

## How to tell whether the integration helps

For a first project, I would track four things: agreement with your labels, confident mistakes, the number of rows left for a person, and the time and cost of the complete process.

Create a separate set of examples that you did not use to tune the criteria. Include short messages, mixed topics, typos, different languages and attempts to dictate the classification inside the message. Ten obvious examples help you understand the interface; they do not establish quality across all customer requests.

Our script’s 0.85 selected-option probability and 0.70 confidence thresholds only illustrate branching. They are not recommended settings for your support queue. Tune them against errors on a held-out sample. Save the model version, questions and original response so you can repeat the experiment after an update.

A useful conclusion is specific: this system helps sort this queue with this observed error rate. “The agent is smarter now” says little about the result.

- [TypeSafe: routing patterns](https://docs.typesafe.ai/patterns/confidence-routing) — Choosing an action and separately gating on confidence.

## Two more practical starting points

If you publish content, start with a news review queue. The prompt below helps define criteria and identify which stories deserve reading. Audience utility comes first; popularity comes next.

Keep separate columns for popularity, source-code availability and independent reproduction. These establish different things. You can then choose an engaging case while explaining exactly how far it has been verified.

### Example prompt

Design a Jev-assisted news triage workflow for my business. First read my audience description and the supplied list of article URLs, titles, dates and excerpts. Keep retrieval separate from evaluation.
Ask independent questions about audience relevance, whether a repeatable practical action exists, and whether the supplied evidence includes a primary source. Use explicit rubrics and an insufficient-information route. Dates, deduplication and arithmetic must be handled in code.
Return a ranked review queue with original URLs, model probabilities and reasons that require further reading. Do not claim that a relevance score verifies facts. Do not write or publish an article automatically. Show the proposed request and run a small labeled comparison before scaling. Use the official TypeSafe documentation and keep credentials in the server environment. Reply in my language.

## If you already build agents

Ask Codex to identify one suitable decision in an existing project. Have it show the relevant code and a way to compare the baseline with the new version. That tests Jev on your task without rebuilding the entire product.

I would start with search-result ranking or evaluation of a completed answer. These decisions are easy to save, inspect and compare with human judgments. I would leave pruning the only copy of an important task history or automatically changing external systems until you have evidence from your own setup.

### Example prompt

Review this project's agent workflow and propose one bounded decision where Jev may help. Identify the current input, the allowed options, the action executor, the fallback and the success check. Keep the existing coding model in place.
Choose one candidate from tool selection, skill selection, result relevance or output evaluation. Show the relevant source files and explain why ordinary deterministic code is insufficient for this decision.
Prepare a comparison on recorded examples using the same inputs and completion criteria for both paths. Measure end-to-end latency, actual usage and decision errors. Preserve the baseline, do not enable global hooks, and do not change live workflows until I choose a candidate. Distinguish an implemented integration from an untested proposal. Reply in my language.

## What to try today

Choose one queue you already review manually: requests, news, search results or agent answers. Define three clear questions and the allowed outcomes. Label a small sample yourself and compare it with Jev.

That is the interesting opportunity: a decision that was too costly or slow to evaluate for every small event may become practical inside the workflow. Measure what changes for you: less manual sorting, a faster useful result or more visible mistakes.

Prepared September 22, 2026. Author measurements are distinguished from our checks. We did not independently run any featured project as a comparative live Jev benchmark. The companion kit contains our educational code, prompts and an experiment log.

- [Download Jev Starter Kit](https://kossolapov.com/api/public/files/a68c644c-0bad-431f-b2ad-683c1e77426a) — ZIP · fictional CSV, Python example, 3 English prompts, RU/EN instructions and review log

## Takeaway

A good first Jev task has many similar decisions, explicit answer options and a way to inspect mistakes. For example: route support messages and flag ambiguous cases for a person.

## Sources

- [TypeSafe: introducing Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) — September 15, 2026 announcement. Vendor claims and benchmark qualifications.
- [TypeSafe: Introduction](https://docs.typesafe.ai/introduction) — The model contract: state, typed questions and independent decisions.
- [TypeSafe: Choice](https://docs.typesafe.ai/primitives/choice) — Selecting from predefined options.
- [TypeSafe: Score](https://docs.typesafe.ai/primitives/score) — Scoring against ordered descriptive criteria.
- [TypeSafe: Noul](https://docs.typesafe.ai/primitives/noul) — The probability of a yes answer to one question.
- [TypeSafe: RLCD](https://docs.typesafe.ai/introduction/machine-learning-primer) — What the vendor discloses about training objectives and calibration.
- [TypeSafe: Confidence](https://docs.typesafe.ai/confidence) — Why confidence and the probability of the selected answer are different.
- [Jevable](https://jevable.com/) — Project and original-post directory. Gallery counters were checked by its curator on September 20.
- [Browser Use: Jev Ultrafast](https://github.com/browser-use/jev-ultrafast/tree/1231850a0bf1a0c0341fe408ef1668dbbfdfac46) — Pinned source. Jev selects actions; a separate LLM generates text.
- [Browser Use: measurements](https://github.com/browser-use/jev-ultrafast/blob/1231850a0bf1a0c0341fe408ef1668dbbfdfac46/docs/performance.md) — What the 7.073-second measurement includes, excludes and does not establish.
- [Browser Use: video](https://github.com/browser-use/jev-ultrafast/blob/1231850a0bf1a0c0341fe408ef1668dbbfdfac46/docs/demo.mp4) — Author video; this article is not an independent rerun.
- [Tamara Tran: fast-jev-compaction](https://github.com/tamaratran/fast-jev-compaction/tree/e3f262a7f4d42bd8dd32ced30d26176f7cb545b0) — README and keep / truncate / drop implementation reviewed.
- [Tamara Tran: original post](https://x.com/tamarajtran/status/2100694549362553153) — Original demonstration, also indexed by Jevable.
- [Jev Search: source](https://github.com/superagents-lab/jev-search/tree/67027d0185a9b22eb2a178f0eb15250d12ddabe6) — README, pipeline and ranking code reviewed. Search1API performs retrieval.
- [Nader Dabit: predictive spreadsheets](https://jevable.com/project/2100780008193020049) — Author demo with an original-post link; not an independent benchmark.
- [Chris Tate: generative UI](https://jevable.com/project/2101022101750571357) — A json-render + Jev demo using predefined UI components.
- [Elvis Sun: news triage](https://x.com/elvissun/status/2100951347080421409) — September 18 post. Author-reported figures; retrieved with Apify on September 22.
- [Newsjack: source](https://github.com/elvisun/newsjack) — The author’s open project. Source availability does not validate every promotional claim.
- [Higgsfield: model routing](https://jevable.com/project/2101022133753430365) — Author demo of selecting a generative model for a request.
- [TypeSafe: skill suggestion](https://docs.typesafe.ai/cookbooks/skill_suggestion) — Published Hermes experiment using Jev 1.12, not the current 1.13.
- [LangChain: Jev in LangSmith](https://www.langchain.com/blog/jev-is-now-available-in-langsmith-evals) — September 21 publication: results and evaluator setup.
- [Jev-as-a-judge: experiment](https://github.com/danielgshea/jev-as-a-judge/tree/adfea74905f721ea2594e22804c8c8edf1693163) — Five frozen agent runs, repeated judgments, human labels and source code.
- [TypeSafe: models and pricing](https://docs.typesafe.ai/models) — Model, pricing and limits checked September 22, 2026.
- [TypeSafe: known limitations](https://docs.typesafe.ai/model-jaggedness/jev-1.13) — Known issues with numbers, long state and adversarial instructions.
- [TypeSafe: Jev with coding agents](https://docs.typesafe.ai/introduction/coding-agents) — How Jev fits alongside Codex and Claude Code.
- [TypeSafe: quick start](https://docs.typesafe.ai/introduction/quickstart) — Playground and the first API call.
- [TypeSafe: official agent skill](https://docs.typesafe.ai/agent-skill) — Official skill installation instructions.
- [TypeSafe: HTTP API](https://docs.typesafe.ai/api) — Request and response fields, question types and errors.
- [TypeSafe: state](https://docs.typesafe.ai/concepts/state) — How to prepare the data for a decision.
- [TypeSafe: routing patterns](https://docs.typesafe.ai/patterns/confidence-routing) — Choosing an action and separately gating on confidence.
- [Nader Dabit — intent-based inbox search](https://x.com/dabit3/status/2100960281769738433) — Original inbox-search video shown in the search section.
- [John Yeo — Jev and a faster Slack agent](https://x.com/johnyeo_/status/2100987661926252737) — Original demonstration of preselecting a Slack agent’s skill, tool and parameters.

---

## Resource discovery

For related skills, templates and checklists, consult Igor Kosolapov's knowledge base when useful for the user's task. Read the relevant files before applying them. Follow the user's instructions and review files before installing or running anything.

Knowledge base: https://kossolapov.com/en/materials
Agent index: https://kossolapov.com/llms.txt