Jev Use Cases

The decision model earns its place when a task is decision-shaped: the possible answers can be named, a careful human could judge it in seconds, and it happens often enough that latency and cost matter. When all three hold, it can be a lower-cost and lower-latency alternative to a generative-model judgment; measure the full workflow before adopting it.

This page maps the patterns where that holds, and the cases where it does not.

Classification and Triage

The canonical fit. Intent, urgency, department, spam, frustration, and refund eligibility are all small, nameable answer spaces judged from text.

• Support triage — classify a ticket's team, urgency, and whether it requests a refund or cancellation, then route to the right queue. Fewer tickets land in the wrong place.
• Content triage at scale — sort feeds, inboxes, notifications, or posts into read / skim / skip.
• Inbound screening — before anything expensive reads a fetched page or pasted message, score it for prompt-injection or jailbreak intent and for relevance.

Design note: split classification from action. Classify in one call, then let code decide where the item goes.

Model Routing

Pick the cheapest model that can complete a request, and route when the task or execution context changes.

const { answers } = await client.systemOne({
  state: { request, recent_context: context },
  questions: {
    needed_model: choice('Which model class should handle this request?', {
      fast: 'Lookups, extraction, localized edits',
      powerful: 'Architecture, multi-file refactors, high-stakes decisions',
      human: 'Ambiguous, sensitive, or outside policy',
    }),
  },
})

For cache-sensitive coding agents, avoid repeatedly switching the main model without measuring cache misses. The model routing pattern covers the cache constraint and the auditability requirement.

Tool and Action Gating

Before an agent executes a tool call, judge whether the action is safe.

• Risk classification — read-only, reversible, or irreversible; blast radius; "touches authentication or payments."
• Shell guardrails — separate Nouls for "deletes files," "rewrites git history," "affects production," and "writes outside the repo." Treat uncertain results as review signals rather than permission to act.
• Auto Mode gates — block dangerous tool calls before they execute, as a classifier layer under the agent harness.

The principle: the classifier does not contain the tool. Routing or gating an action does not shrink its blast radius. Stage destructive permissions after the decision, and own the execution path in code.

Verification and Supervision

Wrap expensive or consequential steps with cheap judgments.

• Tests and claims — did the tests actually pass? Does the output contain an unsupported claim? Is this "done" actually verified?
• Citation support — check each claim against its source transcript and flag low-probability ones.
• Draft review — when an LLM writes the reply, check the draft for policy compliance, whether it answers the request, and whether it contains a prohibited promise.
• Stuck-loop detection — notice when an agent is repeating itself.

This is the "universal verifier" shape: cheap checks around an expensive brain. The confidence gating pattern shows how to route the failing and uncertain cases.

Search and Retrieval

• Reranking — score passages for relevance to a query and select the useful context before a generative model sees it.
• Pointing — decide where in a document an answer lives, rather than generating it. Number the lines, ask a Choice over segments, then a Choice over lines in the winning segment.
• Sufficiency — a Noul for "does this document answer the question at all?" A low value is as useful as a hit, because it stops a downstream model from inventing an answer.

A Choice caps at 255 options, so long documents are handled in stages: segment first, then point.

Context Compaction and Pruning

Score each completed tool result for whether it is still needed, then drop the ones that are not. This replaces a summarization pass with a relevance filter.

The context compaction pattern covers the three-stage design: code selects candidates, Jev scores them, code prunes. Run it in shadow mode and measure token reduction before allowing it to remove data.

High-Volume Labeling and Feature Building

When each decision is almost too cheap to count, record-level analysis becomes possible:

• Corpus labeling — classify records into a fixed topic or category set.
• Row triage — code flags rows that break a rule; Jev labels the anomaly type and priority.
• Feature engineering — turn text into numeric columns for a classical model.

Composite Scoring and Ranking

Combine several independent Scores with your own weights in code. Lead qualification, option ranking, and priority scoring all fit: score company fit, maturity, pain, intent, and urgency separately, then weight them into a single number you control. Changing a weight is a one-line change that does not require a new inference design.

Safety Screening

Prompt-injection and jailbreak scanning, moderation, ad and clutter detection. Because state is data, adversarial text can try to steer the model — write precise criteria and test hostile inputs before you expose the integration.

Bounded Decisions Inside a Policy Engine

Jev interprets the situation; code executes the action; hard risk rules never delegate. Trading regimes and quote environments are the extreme version — the model reads a compact market snapshot and picks a regime, while inventory limits, kill switches, and order placement stay deterministic.

Real-Time and Interactive Loops

Jev can suit interactive loops with bounded decisions: choosing the next browser action, driving a game or simulation, or scoring tone as someone types. Validate latency and decision quality under the actual state size and deployment path.

Where Jev Is the Wrong Tool

The Selection Rule

Pick a card from the deck, don't ask it to name a card. If you need a value that Jev must produce from nothing, it is the wrong tool. If code can find the candidates and the judgment is which one is right, Jev is usually the cheapest way to make that call.

Related

• Prompt Engineering — how to write the questions these use cases depend on
• Confidence Gating — automating the obvious and escalating the rest
• Integrations — the SDKs and middleware that carry these patterns into a real stack