Each page here describes one job: the problem, what to put in the state, the questions to ask, and the decision policy your code writes around the answers. If you want the method before the patterns, read how to build with System One models.
Decide where a piece of work goes next and whether your code is allowed to act on it without a person.
Jev returns a confidence value from 0 to 1 alongside every Choice and Score answer. Your code treats it as a separate axis: act automatically when it's high, confirm or flag when it's middling, hand the decision to a person when it's low. Riskier actions get higher bars.
One Jev call reads an incoming request and returns its intent as a label plus a difficulty rating on a scale you wrote. Your router reads both numbers and picks the handler: deterministic code, a cheap model, an expensive one, or a human queue.
Send a support ticket to Jev once with every question attached. Category comes back as a selected label, severity and frustration as numbers on scales you wrote, refund intent as a probability. Your code reads those values and decides what happens to the ticket.
Ask Jev one Choice question over your tool names and one per closed-set argument, so every value that comes back is a value the function already accepts. Nouls decide whether an optional argument was mentioned at all. Your code assembles the call and runs it.
Judge whether retrieved text is relevant, ranked correctly, or actually supports the claim it is cited for.
An answer with citations is only as good as the citations. Match each quote against the source in code to catch fabrications, then ask Jev one Choice question about how the surrounding section relates to the claim. Confidence decides which verdicts a human reviews.
Two catalogues describe overlapping sets of the same products, and a rough first pass hands you candidate pairs. One Jev Score question with a level per outcome decides each pair, and yes/no questions about individual fields tell a curator where the two sources disagree.
Retrieval returns whatever looks similar, including noise and hostile text. Put a Jev call between retrieval and generation: four yes/no questions per passage return probabilities, and your code decides which passages become evidence, which get flagged as conflicts, and which never reach the prompt.
Keyword or vector search narrows thousands of documents to a shortlist but rarely puts the right one first. Ask Jev one yes/no question about each query and candidate pair, take the probability it returns as the score, and sort the shortlist by it, highest first.
Screen inputs and outputs for injected instructions, policy breaches, and answers that disagree with themselves.
A compliance review is a fixed checklist run against a changing document. Jev answers the whole checklist in one request, returning a probability, a label or a rated level per item, so code can clear the clear-cut findings and send the borderline ones to a person.
Put one Jev request in front of an LLM and one behind it. Yes/no questions return the probability that each hazard holds, a Score rates how much harm complying would do, and your thresholds turn those numbers into pass, review, block, or a crisis path.
Run a rubric over the same document several times and compare the answers. The spread tells you which items sit safely away from a threshold and which ones wobble across it. TypeSafe documents that Jev does not guarantee structural identities between related questions, so code has to enforce those.
A semantic lint is a rule you can state in a sentence but cannot express in a regular linter. Jev turns each rule into a yes/no question over one diff hunk and returns a probability, so CI can comment on the likely violations and stay quiet about everything else.
Turn messy text into typed fields, scores, and labels that downstream systems and models can use directly.
Asking for one overall rating hides the reasoning inside a single number. Score each dimension as its own question instead, normalise each answer to a 0 to 1 range, and combine them with weights your code owns, so a ranking can be explained and retuned without new model calls.
A tabular model needs numbers, and a written note is not one. Ask Jev a set of questions about each row, keep the probability distribution rather than the winning answer, and you get numeric columns that a gradient-boosting model can train on alongside your existing features.
A taxonomy with thousands of leaves will not fit in one question. Ask one choice question per node instead, walking down the tree, and use the probability on each edge to decide whether to follow the single best path or keep several candidates alive.
Jev is not trained to generate text, so it cannot write a value out for you. Extraction works the other way round: a regex or a parser finds candidate spans, a choice question picks the one the question asks for, and code copies that span unchanged.
Pick the next move fast enough for a loop that is already running, whether that loop is a game, a robot, or an agent.
An agent choosing from a long skill roster reads one truncated line per entry and often loads the wrong thing. Jev ranks every entry in one request and separately answers whether any skill applies at all, so the agent gets a short hint instead of a guess.
A model inside a control loop has to answer before the next frame. Jev returns a typed decision rather than text, and TypeSafe reports end to end latency of 70ms to 500ms, which puts a semantic judgment inside the budget of a game tick or an interface response.