Jev is TypeSafe AI's first System One model: it takes text or structured application state, answers questions with a defined set of possible answers, and returns values and probabilities that software can use directly. It can choose a support queue or judge whether a passage backs a claim; it does not write the reply or generate the report. Jev fits workflows where a narrow semantic judgment can become a typed answer, while ordinary code controls what happens next.
Those judgments can sit inside an interactive loop too: choose a control in an app, pick a game action, or select a robot's next bounded step from a structured observation. Keep the generative model for writing and extended reasoning, and use Jev for decisions you can describe precisely and check against examples.
What Jev returns
The TypeSafe API has three question types:
| Question | Use it for | Answer |
|---|---|---|
Choice | Selecting one of the options you supply | Selected option, per-option probabilities and confidence |
Score | Rating one dimension against descriptive, ordered levels | A probability-weighted score, per-level probabilities and confidence |
Noul | Asking whether a statement is true | The probability of yes, from 0 to 1 |
A Noul near 0.5 indicates uncertainty, not a moderately strong version of the property. It has no separate confidence field. For Choice and Score, confidence summarises the returned probability distribution; it is not a guarantee of correctness.
The following 18 use cases are designs to adapt, not claims about customer deployments. The linked documentation and public projects show the underlying patterns. Any automatic action still needs your own evaluation, permissions and failure handling.
Make decisions inside interactive loops
1. Control apps and computers one action at a time
Give Jev a goal, the observed controls and a bounded menu of actions such as click, type, scroll, wait or stop. A Choice selects the operation and another selects its target. The executor checks that the control is still present before acting, then observes the result. A writing model supplies free text when a field needs it.
Browser Use's Jev Ultrafast implements this loop over indexed browser elements. Its recorded flight-search example reports a median Jev-call latency of 178 ms and a 7.073-second interaction sequence after initial page observation. Setup, initial navigation and independent post-run verification sit outside that timer. This is evidence for that example, not a promise that every app runs at the same speed.
For desktop apps, typesafe-computer-use combines OCR and accessibility controls with Jev decisions. Fast model calls make responsive computer-use loops worth testing; capture, perception, execution and loading still determine the pace a person sees. Begin in a sandbox or dry run, and require confirmation before sending, buying or deleting.
2. Play games and explore them for testing
Expose the game's current state and legal actions, ask Jev to choose a move, advance the game and repeat. In a platformer, the menu might be move right, jump, move left or wait. Game code owns timing and physics; Jev supplies the choice at each decision point.
TypeSafe's Doom launch demonstration uses structured text state rather than images. The independent TypeSafe Mario controller turns emulator telemetry into JSON and maps Jev's choices to controller inputs. These show how decision calls can drive play without asking a model to write a plan for every move.
For a game you are testing, adapt that loop to explore menus, attempt objectives or vary player behaviour. Log actions and observed outcomes so a developer can investigate crashes or stalls. That testing application is a proposed extension, not a demonstrated QA result here. Measure observation-to-action delay and missed deadlines: a fast call alone does not establish competitive play or frame-rate control.
3. Choose the next bounded step in physical AI
Turn the observed world into structured state: object locations, gripper state, available skills and observation age. Ask Jev a Choice over the steps the controller currently permits. In a tabletop task, it might select approach, close the gripper, lift, reobserve or stop. A separate perception system must turn camera or sensor input into those facts; hosted Jev does not receive raw images.
RoboJEV demonstrates intent and motion choices for a Franka Panda in MuJoCo, using measured simulator state and independent task-success checks. It is a simulation experiment, not a real-robot deployment. Robo Harness also documents supervised bounded-step Jev trials on an SO-101 arm, alongside hardware faults and failed attempts.
This is a way to evaluate semantic next-step decisions within a larger physical system. The controller must enforce motion limits, reject stale observations and retain an emergency stop independently of Jev. Keep hard real-time motor control outside a cloud decision call, and start in simulation before supervised hardware tests. A confident choice is not a safety certification.
Route incoming work
4. Send support tickets to the right queue
Give Jev the customer's message and a Choice over billing, technical support, account access and other. Describe what belongs in each queue, including the cases that overlap. Code assigns the ticket when the routing meets your tested threshold and leaves uncertain cases for a person.
For a duplicate-charge complaint, routing to billing is enough. Issuing a refund is a separate action with its own checks. TypeSafe's intent-routing pattern describes this separation.
5. Triage bug reports by impact
Ask a Score question with levels such as cosmetic defect, broken feature with a workaround, and blocked work with no workaround. Ask separate questions about lost data or inability to sign in if those conditions need an immediate response.
The output can help order an engineering queue. It should not decide whether an incident meets your service-level commitments: calculate deadlines and elapsed time in code. The Score reference uses bug severity as a worked example.
6. Sort an inbox without sending replies
Use a Choice to label a message as needs reply, update, promotion or other, and a separate Noul to flag an explicit deadline. Keep sender rules and authenticated mail-header checks in code. Start by adding labels, leaving the messages where they are.
The public Jev Cookbook's Gmail recipe demonstrates this pattern. Sorting mail does not require giving a model authority to delete it, click its links or answer on your behalf.
Turn documents into usable records
7. Classify documents before filing them
An intake folder may contain invoices, purchase orders and correspondence with similar wording. Extract the text first, then ask a Choice about the document's purpose. Include an other option and retain the original file alongside its suggested category.
DocJev is a public implementation of document classification and splitting with a separate parsing stage. Hosted Jev accepts text, not PDFs or images, so unreadable OCR is an input problem you must catch before classification.
8. Place products in a category tree
Give Jev a product description and the permitted categories. For a large catalogue, choose a broad category first, then ask a second Choice over that branch's children. Keep a no-match route when the description does not fit.
This is useful when suppliers describe the same kind of item differently. The hierarchical-classification cookbook shows how to traverse taxonomies. Preserve the original supplier label so a curator can inspect a questionable assignment.
9. Flag possible duplicate records
Use exact identifiers to find obvious matches and conflicts in code. For the remaining candidate pairs, ask Jev whether the names and descriptions refer to the same entity. Separate questions can identify which fields disagree.
A suggested duplicate should enter a review queue before you merge important records. The entity-alignment cookbook applies a Score and companion Noul questions to candidate pairs; the model is judging the pair, not searching the whole database.
10. Select the right value from an invoice
An invoice can contain a subtotal, tax, total and previous balance. Let a parser find the candidate amounts, then ask Jev a Choice over candidate IDs to select the requested field. Code copies the chosen source span and normalises it.
The pre-parsed value-extraction cookbook uses this find-then-pick approach. It keeps the returned value tied to the document. Missing candidates still need a no-match outcome, and arithmetic stays in code.
Improve the evidence an agent reads
11. Re-rank a search shortlist
Run keyword or vector retrieval first. For each candidate passage, ask whether it answers the query, then sort the returned judgments in code. Keep document IDs and source links attached to the results.
This gives the answering model a better-defined set of passages to read. TypeSafe's re-ranking cookbook demonstrates the two-stage design. Test retrieval and re-ranking separately: Jev cannot promote a useful document your first search never found.
12. Filter retrieved passages before generation
Relevance alone does not establish that a passage is suitable evidence. Ask separate Noul questions about relevance, usable facts, contradiction and instructions aimed at the agent. Code can pass evidence and conflicting information in separate blocks, or withhold suspicious material.
The RAG-passage cookbook shows this approach. Treat the instruction screen as an additional signal. Jev's own failure-mode documentation warns that adversarial content can steer its answer.
13. Check whether a citation supports a claim
First confirm in code that the quoted words occur in the source. Then give Jev the claim and enough surrounding text to choose supports, contradicts or insufficient evidence. Failed or uncertain checks return to the writer with the source passage attached.
TypeSafe's citation-checking cookbook follows this order. The check evaluates a claim against the supplied document; it does not prove that the document itself is true.
Score work against explicit rules
14. Rank inbound sales leads on named criteria
Ask separate Score questions about stated product fit, buying intent and implementation readiness. Define concrete levels for each, then combine the answers using weights your team can inspect. Missing evidence should remain visible.
The lead-scoring recipe demonstrates this decomposition. A ranking can help someone choose which enquiry to read next. It should not silently replace your eligibility rules or turn a sparse message into invented facts about a buyer.
15. Send questionable content to moderators
Ask one Noul per defined hazard, such as spam, harassment or disclosure of personal information. Different hazards can have different review thresholds. Code decides whether to hold a post, pass it along or flag it for a moderator.
TypeSafe's LLM-guardrails cookbook describes screening both inputs and outputs. Evaluate false positives as well as missed hazards on your own material. A typed result does not make a moderation system immune to attacks.
Give agents bounded decisions
16. Choose among approved generative models
Filter the candidate models by credentials, capabilities, context limits and policy before asking Jev a Choice about task fit. If the judgment is uncertain or the service fails, use the fallback you already defined.
The community pi-jev-router provides an example of model and reasoning-effort selection. This is a routing layer around a generative model. Measure total cost and task quality, including Jev calls and retries, before claiming savings.
17. Suggest the skill a task needs
Send the task and eligible skill descriptions to Jev, rank the candidates, then check the strongest matches before loading one. Allow none as an outcome: a short acknowledgement may need no skill at all.
TypeSafe's skill-suggestion cookbook uses a Hermes skill catalogue and a rank-then-verify sequence. Selecting a skill only loads instructions. It does not grant the agent the data or tool access that those instructions describe.
18. Add an advisory check before risky tool calls
Give Jev a proposed action and the relevant policy, asking narrow questions such as whether the action deletes data or sends information outside the organisation. A flagged or uncertain action can take the existing human-confirmation path.
This extends the guardrail pattern to proposed actions. Keep permission checks and mandatory approvals outside the model, enforced by the host. A favourable Jev answer must never make an otherwise forbidden command executable.
Start with one decision you can check
Take support routing. An illustrative request to POST https://api.typesafe.ai/v1/systemone could be:
{
"model": "jev-1.13.0",
"state": {
"message": "I was charged twice. Please refund the duplicate."
},
"questions": {
"queue": {
"type": "choice",
"instructions": "Which queue should handle `message`?",
"criteria": {
"billing": "Payments, invoices and refund requests",
"technical": "Broken features and service failures",
"account": "Sign-in and account-access problems",
"other": "No listed queue fits, or the message lacks enough detail"
}
},
"refund_requested": {
"type": "noul",
"instructions": "Does `message` explicitly request money back?"
}
}
}
This shows the documented request structure, not a measured run. Each question sees the same state and is evaluated independently. Code reads answers.queue.choice and its confidence, then records a suggested queue or requests review. The refund flag is information for the handler; neither answer authorises moving money.
Before enabling assignment, label a representative set of your own tickets, including messages that fit two queues, lack detail or try to influence the classifier. Compare Jev's answers with those labels. Record wrong automatic routes and how much work goes to review, then set thresholds for the consequences of each mistake. Keep an explicit path for API errors and timeouts.
Pin the evaluated model version and log the version that answered. TypeSafe's aliases can move. Keep exact calculations, date comparisons and permission enforcement in code; Jev 1.13's documented limitations include numeric precision, irrelevant context and option-order sensitivity.
Use Jev alongside KyoubeAI
Jev can work alongside KyoubeAI and its supported harnesses, including Claude Code, pi and Hermes Agent, through a configured server-side API or tool integration. It supplies typed judgments while the harness keeps its generative model. TypeSafe documents an agent skill for building integrations, and its coding-agent guide explicitly explains why Jev is not a drop-in chat-model replacement.
KyoubeAI is an AI operating system for organisations where people and AI employees share work, company data and AI-native apps in a multiplayer environment.
Start with KyoubeAI, choose one of the decisions above, and connect Jev with scoped access and a visible review queue. Keep API credentials on the server. Have an authorised agent or service write the results to company data; KyoubeAI's sandboxed apps cannot call external APIs directly.