Jev: Decision-Oriented Model and Application Programming Interface

• Jev is a decision-oriented model and application programming interface that provides bounded, typed decisions rather than unrestricted text generation, suitable for tasks like natural language intent extraction and system orchestration.
• Jev uses a structured, low-latency approach to make frequent decisions, while larger generative models manage open-ended reasoning and language production, ensuring efficient use of computational resources.
• Jev outputs include binary probabilities, categorical distributions, and ordinal scores, facilitating interaction with downstream systems that require strict adherence to predefined decision structures.

Jev is a decision-oriented model and application-programming interface designed to return bounded, typed decisions rather than unrestricted text generation. Its documented uses include natural-language intent extraction, edge-service orchestration, agentic memory control, scientific and legal semantic judgments, safety and factuality evaluation, visual choice, mobile GUI execution, coding-agent routing, and selective control of language-model agents. Jev is generally positioned as a “System One” component: it performs frequent, structured, low-latency decisions, while larger generative models remain responsible for open-ended reasoning, planning, synthesis, or language production. The available research evaluates Jev primarily as a systems component whose value depends on the decision contract, downstream validator, execution architecture, calibration, and workload.

1. Decision-oriented model and interface

Jev’s defining characteristic is its bounded decision interface. Instead of generating arbitrary text, it receives a structured state and one or more typed questions whose possible answers are specified by the caller. Its outputs may include binary probabilities, categorical distributions, ordinal scores, selected action identifiers, and confidence values. The model is therefore used to select among analyst-defined or system-defined alternatives rather than to construct an unconstrained response.

The interface is commonly described abstractly as a mapping from state and questions to decisions:

$$\mathcal{J}(S,\mathcal{Q}) \rightarrow \{\text{scores, choices, probabilities}\}.$$

The principal question types reported in the research are:

• Noul: a binary decision returning a value such as $P(\text{yes})$.
• Choice: a probability distribution over a finite set of alternatives.
• Score: a distribution over ordered levels and an expected level.

For a Choice question with candidates $o\in O$, Jev returns a distribution $\pi(o)$ over the supplied option set. For a visual candidate set, the selected option is typically:

$\hat{o}=\arg\max_{o\in O}\pi(o).$

The probabilities are conditional on the supplied answer space. They do not necessarily represent calibrated probabilities that the selected answer is correct, and they do not assign probability to alternatives omitted from the caller’s schema. This distinction is especially important in visual choice, legal inference, prompt-injection, and selective-routing applications.

Jev’s bounded output space provides several operational properties. Schema validation can check that all required fields are present and that selected values belong to permitted sets. The downstream system can reject invalid outputs before execution. A decision can also be logged as a discrete relation or action rather than as an opaque generated passage. However, syntactic validity does not imply semantic correctness: a well-formed decision may still misunderstand the request, select the wrong permitted action, or assign an incorrect scientific relation.

The research describes Jev as a commercial “System One” model associated with TypeSafe AI. The supplied papers do not provide a complete account of its architecture, parameter count, tokenizer, training corpus, policy parameterization, or reinforcement-learning objective. One paper characterizes its training paradigm as reinforcement learning for calibrated decisions (RLCD), but does not provide the complete training algorithm (Guo et al., 24 Sep 2026). Jev versions identified in the studies include jev-1.13.0 and Jev 1.13.

2. System-One division of labor

Across the research, Jev is contrasted with System Two: a slower generative model used for deliberative reasoning, synthesis, planning, or natural-language output. The division of labor is architectural rather than a claim about human cognition.

System One performs bounded operations such as:

• classifying an intent into a finite schema;
• choosing a service, locality, quality level, or urgency;
• routing a query across memory graphs;
• selecting an executable tool or GUI action;
• deciding whether retrieval should continue;
• assigning a semantic relation to scientific evidence;
• determining whether a statement is supported, contradicted, or not addressed;
• judging whether an alignment failure is present;
• selecting among visual answer candidates.

System Two remains responsible for tasks such as:

• final answer synthesis;
• complex scientific or legal reasoning;
• long-horizon planning;
• construction of free-form tool arguments;
• policy interpretation;
• clarification;
• strategic game planning;
• and generation of user-facing text.

This separation is explicit in Jev-Mem, where a System-One control plane manages memory organization and retrieval while System Two synthesizes answers (Jiang et al., 21 Sep 2026). It is also explicit in REFLEX, where Jev handles bounded agent control and a strong LLM is invoked when confidence is low or generation is required (Wu et al., 22 Sep 2026). In JEV-Star, JEV selects concrete StarCraft II actions while GPT-6 maintains persistent strategic and tactical goals (Ma et al., 23 Sep 2026). In Jev-Mobile, a vision-LLM creates local GUI goals while Jev selects actions from an accessibility-tree-derived action space (Zhang, 24 Sep 2026).

The division is intended to remove unnecessary autoregressive generation from high-frequency control paths. A generative model may be capable of producing a bounded decision, but its output can involve token generation, formatting, parsing, and sequential calls that the downstream system does not require. Jev instead returns the required decision object directly.

This does not constitute universal replacement of LLMs. Jev is appropriate when the output space is known in advance and the task can be represented through a finite contract. More complex tasks may require richer schemas, uncertainty estimates, clarification, policy reasoning, multi-step planning, an LLM fallback, or human review.

3. Contracts, validation, and downstream execution

Jev’s practical behavior is determined by the contract surrounding the model. A contract specifies the state supplied to Jev, the permitted answer set, validation rules, and the downstream interpretation of each decision.

In edge orchestration, Jev extracts four bounded intent fields:

1. Service: count, detection, OCR, or unsupported.
2. Locality: site only, remote allowed, or unspecified.
3. Quality floor: standard, high, or unspecified.
4. Urgency: normal, urgent, or unspecified.

These fields define $4\times3\times3\times3=108$ possible intent tuples. Jev supplies the bounded intent; a shared validator, admission policy, scheduler, and execution system determine whether and where the service runs. It does not itself select a worker node or construct the execution plan (Li et al., 19 Sep 2026).

In 6G edge orchestration, Jev instead converts natural-language intent into a versioned contract containing permitted workers, a deadline, and a priority. A numerical scheduler then combines the interpreted contract with current wireless and edge state, including serving-cell information, transport delay, queue lengths, worker capacity, offered load, existing placements, and placement-change costs (Li et al., 19 Sep 2026). This separation prevents a semantic interpreter from repeatedly making placement decisions based on stale network state.

The scheduler-based designs treat interpretation latency as part of the request’s end-to-end deadline. In the 6G formulation, if a contract becomes available at time $a_v$ and a request reaches the orchestrator at time $b_i$, the earliest permitted release time is:

$r_i=\max(b_i,a_{v_i}).$

The additional wait caused by contract activation is:

$g_i=\max(0,a_{v_i}-b_i).$

This waiting consumes the same deadline budget needed for transmission, queueing, execution, and response delivery. Consequently, a faster Jev decision can improve completion not only by reducing model latency but also by preserving execution slack.

Validation and execution rules vary by application. In radiology factuality, Jev evaluates whether each candidate report statement is supported, contradicted, or not addressed by a reference report. The evaluation applies the same support question in both directions, allowing unsupported candidate claims and omitted reference findings to be treated separately (Huang et al., 23 Sep 2026). In scientific workflows, Jev selects semantic relations while deterministic code performs counting, filtering, deduplication, arithmetic, covariance substitution, unknown-value handling, and final claim composition (Deng et al., 21 Sep 2026).

For executable agents, typed output constrains the action space but does not guarantee a correct action. In REFLEX, a Jev-selected action must be both a member of the permitted action set and executable from the current state (Wu et al., 22 Sep 2026). In Jev-Mobile, the selected candidate must be valid for the current Android accessibility-tree observation, but the decision may still choose the wrong visible control (Zhang, 24 Sep 2026). In prompt-injection experiments, Jev cannot invent an action absent from the caller’s action set, yet untrusted content can still shift probability toward an unsafe action already present in that set (Wu et al., 23 Sep 2026).

4. Applications in orchestration, agents, and control

Edge-service orchestration

The edge-orchestration studies provide the clearest systems-level evidence for Jev as a latency-sensitive interpreter. In one evaluation, Jev reduced median client decision latency by 15.9–26.5% relative to a structured-output DeepSeek deployment across three measurement blocks. In a real two-node OCR service, Jev achieved 168 of 288 correct, on-time OCR completions, compared with 166 for DeepSeek, while reducing median end-to-end latency by 11.1–25.3% on requests correctly completed by both systems without caching. API fees per correct OCR completion were 69.0–70.6% lower (Li et al., 19 Sep 2026).

Caching changes the comparison. When repeated normalized request descriptions were cached, the latency difference largely disappeared because both systems avoided fresh interpretation. The principal advantage therefore concerned fresh interpretation, especially under bursty arrivals, busy interpreter queues, and deadlines close to the downstream execution time.

In the 6G study, cached interpretation combined with numerical scheduling substantially outperformed direct model-selected placement. Under updated contracts, Jev’s modeled completion rose from 43.24% with direct model-selected placement to 95.59% with cached interpretation and numerical scheduling. At equal observed contract correctness, Jev’s median decision latency was 22.4% lower than DeepSeek’s and 61.9% lower than Gemini’s. Against a quality-matched direct-attribute Qwen configuration, Jev reduced decision latency by 53.0% and improved updated completion by 4.78 percentage points (Li et al., 19 Sep 2026).

Agentic memory

Jev-Mem applies System-One control to memory construction and retrieval. It uses a structured multi-relational memory plane with semantic, temporal, causal, and entity graph views. Jev controls memory typing, candidate relation construction, query routing, graph-budget allocation, traversal depth, candidate scoring, evidence assessment, and adaptive stopping. System Two is reserved for final answer synthesis and selected consolidation operations (Jiang et al., 21 Sep 2026).

On LoCoMo, Jev-Mem reports an overall LLM-as-a-Judge score of 0.777, an 11.0% relative improvement over the strongest listed baseline, memory construction time of 158 seconds, and average query latency of 0.93 seconds. The system uses bounded candidate sets during construction and bounded graph expansion during retrieval. The paper does not supply a conventional ablation table sufficient to isolate the contribution of every component.

Selective agent control

REFLEX places Jev between a small generative model and an expensive strong LLM. Jev proposes an action and confidence; the action is executed autonomously only if it is sufficiently confident and executable. Otherwise, the strong model is invoked.

On the frozen 100-task REFLEX-Sim benchmark, REFLEX at threshold $P(\text{yes})$0 achieved 95% success compared with 88% for a strong-only agent, while reducing strong-model calls from 4.10 to 1.12 per task, a 72.7% reduction. Across three fallback families, strong-model-call reductions were 66.1–71.9%, with strong-token reductions of 50.6–64.1% (Wu et al., 22 Sep 2026).

The benefits are conditional. Ordinary tool selection in BFCL was already 98.4% accurate, while deciding whether any tool should be called was only 52.0% accurate. In the external $P(\text{yes})$1-style evaluation, a cheap generative self-escalation cascade was cheaper and numerically more successful than REFLEX, although the paired success difference was unresolved. Jev therefore provides the greatest value when bounded decisions are frequent, expensive-model calls are unnecessary, and its confidence separates routine from difficult cases.

Game control and GUI execution

JEV-Star combines frequent JEV action selection with persistent GPT-6 planning. JEV selects legal macro and micro actions from structured StarCraft II state; GPT-6 maintains resource reservations, economic goals, army posture, and tactical objectives. The combined system won four reported full games against non-cheating built-in AI difficulties Lv5–Lv7, including two Lv7 victories, with median JEV response time of 0.422 seconds. Mean estimated model cost was $P(\text{yes})$20.15 for JEV and $3.56 for GPT-6 (Ma et al., 23 Sep 2026).

The paper does not isolate GPT-6 planning through a controlled ablation. The combined system also differed from the JEV-only system in candidate descriptions and execution handling. The results therefore establish performance of the completed combined controller rather than a causal estimate of planning’s independent contribution.

Jev-Mobile uses the same general principle for Android GUI agents. A VLM creates a local goal, while Jev repeatedly selects actions from a dynamically regenerated accessibility-tree action space. On AndroidWorld, Jev-Mobile achieved 79% task success, compared with 78% for SeeAct-V and 84% for a step-wise VLM baseline. Among successful trajectories, it reduced mean end-to-end execution time by 32.7% and mean model API cost by 73.4% relative to the step-wise VLM (Zhang, 24 Sep 2026).

5. Scientific, legal, clinical, and evaluation uses

Scientific semantic decisions

In scientific workflows, Jev is used before deterministic computation. On 20 source-grounded Choices across ten scientific cases, repeated five times across 12 configurations, Jev answered all 100 planned semantic questions correctly and all 50 downstream case results correctly. Its median successful-response latency was 0.335 seconds, compared with 1.385 seconds for the next-fastest completely correct and fully available configuration (Deng et al., 21 Sep 2026).

The study emphasizes that final-label correctness is insufficient. In a culture-history case, seven wrong selections changed the correct growth-history counts $P(\text{yes})$3 to $P(\text{yes})$4, $P(\text{yes})$5, or $P(\text{yes})$6, while preserving the final “inconsistent” label. This demonstrates that a correct final claim can coexist with incorrect intermediate scientific quantities.

Crash-narrative coding

Jev can convert police crash narratives into typed variables with probabilities. The crash-coding schema contains 27 questions: 16 presence questions, eight categorical questions, three ordinal questions, and seven gated questions. In an analysis of 195,857 Texas crash narratives, Jev was audited against 2,416 blinded human judgments and coded fields. Against human labels, it achieved precision 0.902, recall 0.915, pooled $P(\text{yes})$7 0.908, and weighted Cohen’s kappa 0.906 (Rafe et al., 21 Sep 2026).

The study stresses that native probabilities require auditing and recalibration. Raw Jev probabilities had pooled ECE 0.0231, while Platt scaling and isotonic regression reduced held-out ECE to 0.0069, approximately a factor of 3.3. A two-decimal probability grid also imposes a resolution floor for rare factors. Consequently, probability outputs should not be used for prevalence estimation, review allocation, or population totals without external calibration.

Legal-document understanding

On ContractNLI, Jev received a shared contract and posed native Choice questions for entailment, contradiction, or not-mentioned. It had the lowest evaluated cost and median latency, with baseline accuracy of 77.38%, median response time of 1.24 seconds, and cost of $0.000228 per contract. Hosted generative models generally achieved higher baseline accuracy (Zhang et al., 23 Sep 2026).

In repeated controlled conditions, Jev achieved 79.44% mean correctness and 23 of 30 anchors correct across all twelve trials. However, five anchors were consistently wrong. The study therefore distinguishes agreement from correctness: a model can repeatedly return the same erroneous legal judgment. It also finds that changing visible hypotheses, requested output volume, or output order can change individual decisions while leaving aggregate accuracy nearly unchanged.

Radiology factuality

For radiology reports, Jev evaluates statement-level support in both candidate-to-reference and reference-to-candidate directions. The OneQ configuration uses one three-way support question per statement and retains similar expert agreement to a seven-question Full configuration while reducing input tokens by 43–45% (Huang et al., 23 Sep 2026).

On RadEvalX, OneQ achieved Kendall correlation 0.573 with total expert error counts and 0.346 with clinically significant errors. On RadEvalExpert, the corresponding values were 0.398 and 0.352. Local RadMatch achieved stronger agreement with clinically significant errors in both expert datasets. Jev detected false negation in controlled tests with AUROC 0.9773, but its category attribution for location and severity errors was weaker than its general detection of factual disagreement.

Alignment and rubric evaluation

RLCDAlignBench evaluates Jev as a zero-shot detector of ten alignment failures across 44 benchmarks, 7,193 detection instances, and five target models. A generic Noul achieved median AUROC 0.886 over 31 usable benchmarks; targeted split-half strategies achieved median AUROC 0.911 over 38 usable benchmarks (Guo et al., 24 Sep 2026).

The results depend strongly on the state shown to Jev. Many alignment failures are relational and require references such as the user’s belief, an injected instruction, a source answer, a secret list, or a target-model probability. Fields that encode the benchmark label can produce large gains. The study also finds pooled calibration that is better than per-benchmark calibration, reflecting prevalence mismatch across datasets.

In rubric judging, Jev was compared with three flash-tier LLM judges over 5,003 unit–criterion pairs from seven benchmarks. Jev’s accuracy differed significantly from an LLM judge’s in only eight of 27 paired comparisons. It was generally competitive on binary criteria and weaker on graded criteria. Jev cost $P(\text{yes})$81.844 for Luna, $P(\text{yes})$94.183 for DeepSeek; wall-clock time was 28.6 seconds for Jev versus 859, 950, and 6,298 seconds, respectively (Rao et al., 24 Sep 2026).

Jev confidence often ranked its own errors, but its errors were highly correlated with LLM-judge errors. Post-hoc cascades reduced cost but produced at most a 1.5-point average gain over the best single judge with cross-fitted thresholds and at most 2.0 points with oracle thresholds. The evidence supports Jev as a cheap first-stage evaluator, not as a reliable source of large accuracy improvements through naive cascading.

6. Visual decisions and multimodal extensions

Jev-style interfaces have been extended to visual inputs. Visual Jev uses a vision-language backbone that encodes an image and public context once, caches the shared prefix, and executes multiple isolated question suffixes in a batch. It reads candidate probabilities directly from the existing language-model head (Yu et al., 22 Sep 2026).

Answer-supervised adaptation increased equal-weight macro accuracy from 0.706 to 0.761 across GQA, SNLI-VE, TextVQA, and TallyQA. The improvement was concentrated on GQA and SNLI-VE, which were represented in training; held-out TextVQA and TallyQA changed little. At 32 questions per image, prefix sharing plus batching was 8.9 times faster than independent serial execution and 3.4 times faster than a batched baseline that recomputed the prefix. Peak memory increased from 8.40 GiB to 10.10 GiB.

PixelJev extends the interface to native image decisions. It maps an image, instruction, and runtime candidate schema to a valid choice and candidate-conditioned probability distribution. The implementation uses Qwen3.5-2B and 4B models, candidate-token readout, and optional language-side LoRA adaptation (Zhou et al., 24 Sep 2026).

On Oxford-IIIT Pets, 64-shot source adaptation raised Qwen3.5-2B accuracy from 60.13% to $o\in O$0. On CIFAR-10.1, DTD, and A-OKVQA, the adapted model transferred without target fitting, but transfer was not uniform. Frozen Qwen3.5-4B outperformed adapted 2B on DTD and ScienceQA, and DINOv2 specialist probes remained stronger on source recognition tasks.

These studies separate three properties:

• Validity: whether the output belongs to the permitted candidate set.
• Accuracy: whether the selected candidate is correct.
• Calibration: whether candidate probabilities correspond to empirical correctness.

Candidate readout can improve validity without improving visual reasoning. In adapted ScienceQA, direct candidate readout recovered decisions that ordinary generation expressed as invalid outputs, but the paper does not establish that candidate readout itself improved visual evidence use.

JEVQA evaluates Jev as a zero-shot video-quality model. Using metadata only, it achieved PLCC 0.737 against VMAF in a study of 1,936 AV1, H.264, HEVC, and VP9 encodes, comparable to ITU-T P.1204.1 Mode 0 at 0.733. Bitstream features raised PLCC to 0.797, and combined bitstream and pixel features to 0.824. Pixel features alone produced PLCC 0.226. In a subjective MOS study, metadata-only JEVQA reached PLCC 0.879, close to P.1204.1 at 0.898, while trained task-specific models remained stronger (Robitza, 21 Sep 2026).

The video results show that zero-shot decision performance depends heavily on feature representation and encoding regime. Bitstream features helped CRF-controlled encodes but reduced absolute MOS prediction for bitrate-controlled encodes, although within-ladder ranking remained useful. This limits the interpretation of Jev as a drop-in replacement for trained video-quality models.

7. Calibration, security, limitations, and deployment principles

Calibration and selective use

Jev’s probability outputs are useful only when their semantics and calibration are understood. Multiple studies distinguish ranking quality from probability calibration. In crash coding, raw probabilities required recalibration before prevalence estimation. In visual decision, temperature scaling sometimes improved NLL while worsening ECE. In alignment detection, pooled calibration was substantially better than per-benchmark calibration because base rates varied. In REFLEX, confidence was useful for risk ranking despite only moderate calibration.

Selective systems therefore commonly use thresholds, abstention, or fallback models. A typical policy is:

$o\in O$1

otherwise, invoke a stronger model or human reviewer. Thresholds must be selected on representative data, and low confidence should not be confused with an authorization guarantee.

Prompt injection and decision hijacking

Typed output constrains the output space but does not eliminate prompt-injection risk. In a study of 510 reconstructed InjecAgent direct-harm cases, malicious content shifted Jev’s action probabilities but rarely caused attacker-target selection. Base attacks produced 1.8% attacker-target selection in the primary three-choice space; enhanced override markers reduced this to 0%. Adaptive attacks using score feedback increased fresh-validation success from 1.8% to 3.5% and nearly doubled the mean highest attacker-target probability from approximately 0.043 to 0.084 (Wu et al., 23 Sep 2026).

The security distinction is:

$o\in O$2

Jev cannot invent an undeclared action, but it may select an unsafe action that the caller has already included. Systems using Jev must therefore protect the state supplied to the model, constrain action sets, validate authorization independently, and evaluate probability shifts rather than only malformed outputs.

Enterprise routing and cost control

In coding-agent infrastructure, Jev classifies prompts against an enterprise-defined taxonomy containing action, domain, complexity, context dependence, stakes, and output shape. A cache-aware router uses these probabilities to select models at session start, in side lanes, or at subagent launch, while avoiding arbitrary mid-session switching that destroys model-specific prompt caches (Abbasi et al., 24 Sep 2026).

The reported emulation of 10,000 seats estimates 14–21% recovery of model spend, equivalent to $o\in O$35.0 million annually under the specified Anthropic prices and workload model. These figures depend strongly on cache pricing, tool-heavy sessions, correction chains, synthetic tasks, and assumptions about model capability. The more general architectural principle is that routing should be priced at the level of the cached conversation and completed task, not an isolated API request.

General limitations

Across the research, the principal limitations are:

• Bounded-schema dependence: Jev assumes that relevant decisions can be specified in advance.
• Model and provider dependence: results depend on Jev version, serving infrastructure, API conditions, and deployment configuration.
• Calibration transfer: probabilities may not remain calibrated across domains, base rates, candidate sets, or releases.
• Semantic ambiguity: a valid bounded output can still be semantically wrong.
• Incomplete state: relational judgments fail when required reference information is absent.
• Correlated errors: Jev and generative models may fail on the same examples, limiting cascade gains.
• Candidate-set dependence: probabilities and decisions can change when options, ordering, or descriptions change.
• Limited evaluation breadth: several studies use curated, synthetic, repeated, or small benchmark samples.
• Downstream confounding: complete-system comparisons do not always isolate Jev from adapters, execution rules, prompts, or candidate construction.
• Security limitations: schema validation prevents undeclared outputs but not adversarial selection among declared actions.
• Commercial opacity: the supplied research does not disclose Jev’s full architecture, training data, or internal calibration procedure.

The cumulative evidence supports a constrained interpretation of Jev. It is not a universal substitute for generative models or task-specific supervised systems. Its most defensible role is as a fast, typed, auditable decision layer placed before deterministic execution or before expensive reasoning. The strongest designs combine bounded contracts, independent validation, cache reuse, numerical or rule-based downstream control, calibrated fallback policies, and evaluation at the level of both intermediate decisions and final task outcomes.