Jev and the decision before the next click

Andy Gao tells his Mac to “open the notes app and create…” The app opens before he finishes the sentence. His September 18 demo uses Jev, TypeSafe AI’s decision model.[1]

The interesting question is not just how fast it responds. It is which part of the job Jev actually does.

Something has to transcribe the speech. Something has to know the available apps and actions. Something has to open Notes. Jev participates in the judgment between those steps: given the information available, what should happen next? It is not the whole computer-use system, and it does not independently see the screen.

Calling Jev a mouse captures an important shift in emphasis. A generative model produces content; a decision model helps software choose where to go. But the more precise analogy is the selector behind the mouse. It assigns probabilities to bounded alternatives. Permission to click, timing of the click, and confirmation that it worked belong elsewhere.

In code, the shape is familiar: if-else.

Checking whether a file exists, a balance exceeds a limit, or a date has passed is a job for ordinary code. The awkward conditions are semantic: Is this customer asking for a refund? Does this retrieved passage support the claim? Is a failed tool call worth retrying? These require understanding, but they do not necessarily require a paragraph.

A decision without an answer stream

Jev is a hosted decision model from TypeSafe. Founder Diogo Almeida’s launch thread appeared at 02:17 on September 16 in Beijing, or September 15 UTC. As of September 20, the documentation lists Jev 1.13, with the versioned ID jev-1.13.0.[2][3]

A request supplies a state plus questions whose answer types are defined by the developer. The state can be text, a JSON object, or an array of text values. The current model does not accept images, audio, or video directly. Other components must first turn those inputs into text or structured fields.

There are three output primitives:

• Choice selects from a finite set. A support router might offer billing, technical, sales, and needs review. The response includes the selected option, a distribution over options, and a confidence value.
• Score evaluates against ordered descriptions. A relevance rubric might run from unrelated to directly resolves the request. The returned score is derived from the distribution over those levels; it can fall between them.
• Noul returns the probability of a proposition being true. “Does this message explicitly request a refund?” produces a value between zero and one. There is no additional confidence field. A value of 0.5 means an even yes/no split, not a medium-strength refund request.

Several questions can share the same state and be evaluated in parallel. Rather than ask whether a code change is good, a developer can ask whether it touches authentication, removes tests, or changes a public interface, then combine the results in code.[4]

This is not a claim that language models cannot decide. Classification, tool selection, and structured output are established LLM uses. Jev packages that work separately: a decision interface without a detour through generated prose.

TypeSafe calls the category System One and its training method Reinforcement Learning for Calibrated Decisions, or RLCD. The stated aim is to make probabilities track outcomes. Public materials do not provide enough detail to reproduce the complete training method or independently establish every architectural claim. The useful interface is observable; a new name alone does not establish a new scientific category.[2]

A valid answer can still be wrong

Consider a router allowed to return only finance, support, or engineering. It cannot invent a fourth department. It can still send a refund complaint to engineering.

That is the limit behind Jev’s “cannot hallucinate” pitch. The guarantee TypeSafe emphasizes concerns matching the predefined schema and answer space. It does not eliminate mistaken judgments within that space. The company’s own limitations page describes problems with arithmetic, dates, indirect wording, irrelevant context, and adversarial input.[2][5]

Type validity concerns the allowed answer. Calibration concerns the relationship between probabilities and observed outcomes. Safe execution also requires permissions, rules, and risk controls.

If a group of comparable predictions receives probability 0.8, good calibration means the event should occur about 80 percent of the time in that group. It does not grant any one action a safety certificate.

Nor is confidence an independent second opinion. TypeSafe says it derives that statistic from the shape of the returned distribution. A concentrated distribution generally yields higher confidence. The number is not interchangeable with accuracy.[6]

The candidate set matters just as much. Offer only refund and reject, and a model may confidently pick the less inappropriate answer. The action the situation really needs—check the order first—was never available.

One of the most valuable options is therefore an unglamorous one: do not act yet; get more information.

Where the selector belongs

A dependable software operator needs at least five stages: observe the state, bound the available actions, evaluate them, enforce policy, then execute and verify.

This is a proposed system design, not a list of capabilities supplied by Jev. Jev mainly participates in the third stage. Perception components, ordinary code, tools, and sometimes human approval supply the rest.

For browser work, a system could extract button names and states from the DOM or accessibility tree, present only currently permitted actions to the selector, then check the returned ID against an allowlist. If the page changes, it should refresh the state rather than click an object from an obsolete snapshot.

That gives the if-else analogy a practical meaning: code keeps the deterministic rules; the model estimates the semantic conditions. Model output does not override the rules.

The following illustrates control flow. It is not Jev SDK code, and it does not prescribe production thresholds:

# Learn threshold from labeled examples in this workflow.
if not permission_allows(action):
    reject()
elif not state_is_fresh() or evidence_is_missing():
    request_review()
elif risk_is_unacceptable():
    request_review()
elif not relevance_passes_threshold():
    use_slower_path()
else:
    execute_once(action)
    verify_result()

Jev may help estimate relevance, intent, or certain risk signals. Permissions, state versions, idempotency, and outcome checks should not become questions the model is free to answer however it likes.

What the early applications actually show

PR triage turns one broad judgment into several narrow ones. On September 17, Paolo Rosson showed a diff going through 14 typed checks, followed by code choosing block, security review, small fixes, or merge. He reported six PRs in the video, at about $0.00007 per Jev call.[7]

That is evidence of an interesting application pattern, not a replacement for comprehensive code review. Six inexpensive examples do not establish coverage of cross-file vulnerabilities, missed context, or costly false negatives. A more defensible role is a cheap triage layer alongside tests, static analysis, and reviewers.

Paper classification separates generation from selection. Hassan’s September 17 workflow summarized 1,018 papers with DeepSeek V4 Flash, then sent each title and summary to Jev with 24 topic choices. He reported $3.99 for summaries, $0.08 for classifications, and 256 milliseconds median end-to-end classification latency. He also said he was evaluating the classifications before replacing the existing ones.[8]

The division of labor is useful. The generator compresses long documents; the selector classifies them. It also creates two possible error sources: an inaccurate summary can remove information the classifier needs. These are author-reported workflow figures, not universal service guarantees.

Fast voice control raises a timing problem. The Mac demo is compelling, but a September 20 Beijing-time reply asks the more consequential question: what happens if the speaker pauses or changes their mind halfway through? How does cancellation or rollback work?[1][9]

Opening an app is usually recoverable. Sending an email, submitting a payment, or deleting a file is different. A sensible design would permit low-risk preparation while waiting for a complete, authorized intention before committing irreversible actions. That is a design proposal prompted by the discussion, not a safety property demonstrated by the video.

The open ecosystem contains three different approaches

The official materials reviewed describe Jev as a hosted model, without public weights. A repository with Jev in its name may call the service, copy the interface, or implement an entirely different model. Those are not equivalent releases.

Read candidate scores from an existing model

TheoLeeCJ/SemIf, formerly named OpenJev, reads scores for declared answer tokens from existing open models instead of first generating a JSON answer. Its code is MIT-licensed; underlying weights retain their own terms.

This is a useful way to test whether a model you already have can act as a semantic if statement. But normalizing candidate scores so they sum to one does not establish calibration. Candidate wording, ordering, quantization, and domain shifts can all affect behavior.

Train specifically for decisions

Mapika/decider publishes training, evaluation, and inference code plus open weights. The code and reviewed 2B checkpoint carry Apache-2.0 licenses. It is a post-trained decision-model approach, with code updated on September 20. The project also documents limitations around English-only scope, complex reasoning, and difficult examples.[13]

Bespoke Nimble post-trains Qwen3.5-9B and provides an Apache-2.0-labeled checkpoint. It is not just an API wrapper. Its authors warn about limited training domains and generalization beyond their small holdout. At the research cutoff, the GitHub code repository had no detected license; the checkpoint license should not be silently applied to the code.[13]

Open training and evaluation artifacts make these projects worth studying. They do not make leaderboard numbers comparable. A claim that one beats Jev needs shared test data, judgment criteria, and a meaningful latency comparison—not a collage of README figures.

Adapt a diffusion model into a structured reader

The “DiffusionGemma as Jev” post shared by Google Gemma on September 19 points to another route: use a diffusion canvas with designated answer slots and read candidate distributions rather than generate a sequential answer. The enabling vLLM PR #57250 was created on September 17 Beijing time. It remained open and unmerged when checked on the evening of September 20.[10]

razorback16/openjev supplies a corresponding service layer. The appealing possibility is to use the same resident weights for ordinary generation and bounded decisions. The costs include an experimental runtime, model footprint, and deployment work. This is not a feature to assume is available in a stable vLLM installation.

It should also be distinguished from githubnext/localjev. That project asks a normal chat endpoint to generate JSON probabilities, then reshapes the result into a Jev-compatible response. Similar wire formats do not imply identical measurements. Generated probabilities and scores read from candidate positions are different things; neither automatically inherits Jev’s claimed calibration quality.

What is genuinely new on September 20

The dates in this section use Beijing time, UTC+8. A newly created repository, a code update, and a repost are different events. These are selected, traceable developments—not a census of every related X post.

Access is getting easier. TypeSafe’s official account today reposted a Vercel Developers announcement that Jev is free on Vercel AI Gateway through September 25. This is a promotion, not a promise of permanently free input. Availability and conditions should be checked at the gateway. Vercel, Cloudflare, and LangChain have official integration materials; they distribute or orchestrate the hosted product, rather than open-source its model.[11][12]

Filter coding-agent tool results before the generator reads them. Astro-Han/jev-harness, created at 09:08 today, explores Jev-based filtering with an A/B harness. The useful question is whether it removes irrelevant context without removing essential evidence. A smaller token count alone is not success.

Compare decision backends inside a robotics simulator. FBddcz/embodied-jev, created at 11:38, connects local models, hosted Jev, and compatible endpoints to a MuJoCo workbench. Separating the control harness from the backend is the reusable idea. The repository retains failures and timeouts and limits its conclusions. Simulation experiments are not real-robot safety certification.

Combine direct score reading with compressed weights. NicolaiLassen/open-bonzi-jev, created at 16:15, pairs SemIf-style readout with Bonsai weights for laptop-local judgments. Its own examples include confident mistakes—a helpful warning against treating within-candidate scores as truth.

Expose local bounded decisions through MCP. GenericJevMCP-via-DiffusionGemma, created at 15:49, provides MCP, CLI, and HTTP surfaces. It explicitly describes its probabilities as uncalibrated and normalized only within supplied candidates. This is material for a local toolchain experiment, not immediate control of consequential actions.

These are fresh experiments, not four mature foundation models. The clearest movement is in composition: take existing weights or an API, give them a bounded judgment interface, and place that interface inside a coding, tool, or control loop.

Ten places to try it—and the brake each needs

The following are application proposals, not ten established Jev product capabilities. Good candidates have explicit alternatives, observable mistakes, and a fallback when the judgment is weak.

1. Support triage. Use customer text and order context to infer intent, destination, and escalation need. Let code check order status and refund authority. Measure misrouting and repeat transfers, not just tickets processed.

2. Model routing. Choose a cheap model, a stronger model, or a tool lookup. Include failed cheap-model attempts and retries in the bill. A low-cost first call that creates more downstream failure is not a saving.

3. Retrieval filtering. Judge whether passages are relevant, current, and supportive of a specific claim. Keep source locations and original text. Scores assist verification; they do not replace it, especially where discarded counterevidence could change the answer.

4. Coding-agent control flow. Choose among reading files, running tests, implementing a fix, or stopping with a report. Enforce file boundaries and iteration budgets in code. Do not let a cheap selector make an infinite retry loop affordable.

5. PR risk triage. Identify authentication, migration, and public-interface changes and prioritize review. A low-risk score is not approval to merge. Preserve tests, static analysis, and required reviewers.

6. Voice-assistant preparation. Open an app or prepare a search during streaming transcription. Wait for explicit authorization before sending, paying, or deleting. Build cancellation and measure false triggers alongside latency.

7. Notification sorting. Select interrupt now, read later, or archive using real user feedback. Retain hard rules for important contacts and an accessible recent-archive view. Quiet should not mean missed obligations.

8. Publication checks. Separate missing sourcing, overstated headlines, and image-text inconsistencies into distinct questions. Factual verification still requires evidence. Fluent copy is not evidence that its claims are true.

9. Game NPCs and simulated agents. Let a slower planner set goals and a fast selector choose from currently legal actions. The engine enforces collisions, resources, and cooldowns. Simulation latency does not establish reliable real-world control.

10. Operations and risk-review queues. Rank incidents, logs, or anomaly descriptions by likely cause and urgency. Keep arithmetic, account permissions, transaction execution, and final approval in deterministic processes. Decisions affecting people’s rights need review and an appeal route.

Support routing, evidence filtering, and reversible low-risk branching are sensible starting points. Automatic payments, production-database deletion, and denial of customer rights are poor first demonstrations of speed.

Count the mistake, not just the call

TypeSafe currently lists $0.042 per million input tokens, with free output. A request consuming 1,000 input tokens would cost $0.000042 in model input charges; a million such calls would cost $42.[3]

That excludes transcription, summarization, retrieval, retries, failed execution, and human review. The vendor’s reported 70–500 milliseconds is also not a universal SLA across regions, loads, and input lengths.[2]

A small but complete deployment experiment is more informative than another demo:

• Label real workflow examples, including ambiguous, malformed, and adversarial inputs. Split by customer or source where needed to prevent near-duplicate leakage.
• Freeze the model version, wording, and candidate definitions. Compare against rules, an ordinary small model, or the current workflow—not only the most expensive available model.
• Record accuracy, dangerous mistakes, abstention rate, end-to-end P95 latency, and cost per successful task. Check whether probability bands correspond to observed outcomes.
• Begin in shadow mode: record the model’s recommendation while the existing process remains in charge. Only then expose a small share of reversible, low-risk work to automatic branching.
• Retest after changing weights, quantization, prompts, or candidate sets. Define fallback behavior for timeouts, outages, and uncertainty.

Jev does not replace if-else. It supplies an approximate answer to some conditions developers previously struggled to express. Whether that improves the software depends on what happens when the answer is wrong.

When watching the next impressive clicking demo, look for a clear path that ends without a click.

Sources and scope

Research cutoff: evening of September 20, 2026, Beijing time. Performance figures are attributed to the vendor or demo author, not independently reproduced here. New-project dates use GitHub repository creation timestamps converted to UTC+8; a push is not a launch. X coverage is a selection of verifiable posts and discussions, not every related post on the platform.

1. Andy Gao’s Mac voice-control demo
2. TypeSafe’s Jev introduction; Diogo Almeida’s launch thread
3. TypeSafe models, pricing, and input support
4. TypeSafe API and typed outputs
5. Known Jev 1.13 limitations
6. TypeSafe confidence guide
7. Paolo Rosson’s PR-checking workflow
8. Hassan’s paper-summary and classification pipeline
9. Discussion of voice-command cancellation and rollback
10. Google Gemma on DiffusionGemma as Jev; Matt Mastracci’s comparison and its scope
11. TypeSafe’s September 20 repost of the Vercel promotion; Vercel model page
12. Cloudflare integration; LangChain integration
13. Bespoke Nimble checkpoint and model card; Decider 2B weights
14. Research leads: the original Xinzhiyuan report and its linked TestingCatalog post. Technical claims were checked against primary documentation and the project repositories linked in the text.