Jev case library

Real-world cases

This library collects Jev uses published by their builders. Each entry says what goes into Jev, what it decides, how code uses the answer, and what we could verify. Search or filter by source evidence above the cards.

“Public code” means the repository and usage can be inspected; we have not run its API or verified production outcomes. “Author post only” means we read the builder’s original X post but could not inspect code, inputs or performance. Community projects on GitHub or X are not official TypeSafe projects. We have not reproduced third-party measurements below.

Browser agentCode + author post

jev-ultrafast

Author / team: Browser Use / Gregor Zunic

Input: Visible page controls and the user's goal.
Jev decision: Jev selects an action and an indexed page element in one request; a small text model is used only for typing.
Next action: The executor rechecks the target, acts in the browser, then independently verifies the outcome. The flight example stops at results; it does not book.

Evidence limit: The repository's timing covers its own sample task, not general reliability.

Original sources: GitHub X

Coding agentCode + author post

fast-jev-compaction

Author / team: Tamara Tran

Input: Tool calls, results and surrounding context from an agent transcript.
Jev decision: Two Noul questions per eligible call ask whether the call and its full result still matter.
Next action: Code thresholds keep, truncate or remove call/result pairs while user and assistant text stays intact.

Evidence limit: Compaction can discard evidence needed later; on failure the library throws and leaves fallback to the caller.

Original sources: GitHub X

Document processingPublic code

DocJev

Author / team: Jerry Liu

Input: Page text from PDF, DOCX or PPTX files plus natural-language category rules.
Jev decision: Jev predicts document categories and boundaries within a combined packet.
Next action: The program outputs categories, page ranges and review flags, and can export split PDFs.

Evidence limit: Text extraction may run locally, but Jev inference is hosted; difficult OCR is a separate optional step.

Original sources: GitHub

Database retrievalCode + author post

pg-jev

Author / team: Zachi

Input: PostgreSQL rows and a natural-language condition written in SQL.
Jev decision: The extension batches one Noul question per row and also exposes Choice and Score functions.
Next action: Probabilities return to SQL for filtering, sorting and grouping, with session-level caching by row content.

Evidence limit: Evaluated row data can leave for an external API; latency and cost figures are measurements from the author's environment.

Original sources: GitHub X

Request routingPublic code

hono-jev-router

Author / team: Yusuke Wada

Input: An HTTP request's method, URL, redacted headers and part of its text body.
Jev decision: Each semantic route becomes a Noul question; all descriptions are evaluated in one Jev call.
Next action: Code picks the first registered route above its threshold and falls through when none match.

Evidence limit: The author calls this experimental and warns against using semantic routes for authentication or authorization.

Original sources: GitHub

Agent tool reviewPublic code

jev-guard

Author / team: leepokai

Input: A proposed coding-agent tool call, recent user instructions and content the agent read.
Jev decision: A Score rates risk; Noul questions examine approval need, user intent and instructions planted in untrusted content.
Next action: Project code maps answers to deny, ask or allow and connects through host-specific hooks.

Evidence limit: This community judgment layer does not replace host permissions, human approval or security boundaries.

Original sources: GitHub

Support triagePublic code

typesafe-jev-examples · ticket triage

Author / team: Rajiv Kuriakose

Input: One support ticket.
Jev decision: One request asks Choice for the department, Score for business impact and Noul for churn signals.
Next action: Code applies different routing thresholds by risk and keeps an other option for out-of-scope tickets.

Evidence limit: This is a runnable example; the author reports testing the OpenRouter path, not the direct TypeSafe path.

Original sources: GitHub

Email classificationAuthor post only

500-email classification demo

Author / team: Riley Brown

Input: The 500 emails in the author's demo.
Jev decision: The author classifies the batch with Jev; the post does not disclose question types, labels or thresholds.
Next action: The demo shows classifications; the author reports seconds of runtime and a 3.5-cent cost.

Evidence limit: Only the original post was checked; code, email samples and independent billing records were unavailable.

Original sources: X

Personal file organizationAuthor post only

Downloads folder sorter

Author / team: Marcel Pociot

Input: New files in a macOS Downloads folder and user-defined rules.
Jev decision: The author's example asks whether a file is an invoice; the post does not publish question types or fields.
Next action: The app moves and renames files according to rules; the author says it uses no other language model.

Evidence limit: This is an author demo; source code, file extraction and error handling were not verifiable from the post.

Original sources: X

Content analysisAuthor post only

3,282-post analysis

Author / team: Ian Nuttall

Input: The author's 3,282 X posts and their performance data.
Jev decision: Eight questions per post cover topic, hook, tone and whether it teaches something; the post does not state Jev question types.
Next action: The author combines judgments with existing engagement data to identify patterns in better-performing posts.

Evidence limit: The sample is one account; cost and growth findings are self-reported and do not establish causality or cross-account performance.

Original sources: X

Historical prediction analysisPublic code

hn-oracle

Author / team: Anthony Maio

Input: Historical Hacker News comments and their context.
Jev decision: A first-stage Noul judges whether a comment predicts the future; after a threshold, Noul, Choice and Score questions assess checkability, direction, subject and horizon.
Next action: Code selects predictions for later hindsight grading, records structured fields and publishes results from a preregistered 1,000-comment pilot; the full archive has not been processed.

Evidence limit: Accuracy, cost and calibration figures are reported by the author; probabilities need a separate calibration step, and full-archive scale and runtime remain projections.

Original sources: GitHub

Message tone previewCode + author post

undertone

Author / team: Numan

Input: A message drafted before sending.
Jev decision: One Jev request uses Choice, Noul and Score to judge overall tone, signals such as sarcasm or pressure, urgency and whether the message suits a manager.
Next action: The interface shows a tone label, color and phrase tips; the user decides whether to send.

Evidence limit: There is no independent accuracy measurement; without an API key or on request failure the app uses an offline keyword classifier, so the entire demo cannot be attributed to Jev.

Original sources: GitHub X

Web searchAuthor post only

JevSearch web reranking

Author / team: Kyle Jeong

Input: A user query, selection criteria and roughly 25 candidate pages returned by Browserbase search.
Jev decision: Jev scores candidate results against the selected relevance criteria.
Next action: The program returns five higher-scoring results; the author says Jev sometimes selects pages outside the search engine's initial top five.

Evidence limit: The author post and TypeSafe's repost were checked, but no public code, sample queries or independent relevance evaluation was found. This is not a TypeSafe project.

Original sources: X TypeSafe X

Contract text comparisonPublic code

Jev Audit

Author / team: neozhu

Input: A baseline contract and OCR text extracted from a scanned copy.
Jev decision: One Jev call uses Noul, Choice and Score to judge substantive term agreement, signs of edits, difference type and closeness of terms.
Next action: Code combines answers into a weighted consistency score; the author's policy passes above 90%, while other results go to human review in an inspectable report.

Evidence limit: Contract text goes to the TypeSafe API; optional question generation also calls OpenAI. This site did not run the API or validate legal conclusions. The 90% cutoff is the author's choice, and original terms still need human review.

Original sources: GitHub

Model routingAuthor post only

OpenRouter model selection with Jev

Author / team: OpenRouter

Input: An incoming OpenRouter LLM request and conversation context; the author's post says routing is cache-aware.
Jev decision: Jev judges task type, difficulty, precision needs and likely benefit from a larger model, then selects a model and reasoning effort.
Next action: OpenRouter forwards the request to the selected model and includes routing metadata; its post says a Jev timeout or invalid output fails the request.

Evidence limit: The OpenRouter post, product page and TypeSafe repost were checked, but no public router source or independent quality and cost evaluation was found. This is a third-party product, not a TypeSafe first-party project.

Original sources: OpenRouter X OpenRouter details TypeSafe X OpenRouter

Coding-agent retrievalPublic code

jevgrep code-context retrieval

Author / team: dzhng

Input: A coding-task question, repository hierarchy, file previews and source units.
Jev decision: Jev uses bounded yes-or-no relevance judgments to select folders, files and code locations across the repository hierarchy.
Next action: The CLI returns verbatim source excerpts with line references and reading leads; the coding agent then edits and tests separately.

Evidence limit: Eligible source content is sent to the chosen external Jev provider. The author's cost and solve-rate figures apply only to their sample, and retrieval may miss relevant files.

Original sources: GitHub

Request quality checksPublic code

wellposed Jev request lint

Author / team: suraj-phanindra

Input: The state, question types, instructions and criteria in a proposed Jev request.
Jev decision: Offline rules catch structural defects; for semantic issues they cannot settle, the tool asks Jev Noul questions, such as whether a realistic input fits none of the offered choices.
Next action: The program reports warnings and suggested fixes before a production request; the developer decides whether to revise it.

Evidence limit: Semantic linting itself needs a TypeSafe API key and may send request content. The author's labeled samples and accuracy figures were not independently reproduced; warnings do not replace testing.

Original sources: GitHub

Community moderationPublic code

jevmod community moderation

Author / team: ohernandezdev

Input: A message's text, channel topic and community-defined rules.
Jev decision: Jev answers separate Noul questions for categories such as scams, spam and harassment, returning a probability for each.
Next action: Policy thresholds flag messages for moderator review; deletion is off by default and requires explicit enablement.

Evidence limit: Message text and channel topic go to TypeSafe; on Jev failure the program leaves messages alone and logs the error. The author's accuracy and cost figures were not independently reproduced, and human review remains necessary.

Original sources: GitHub

Android device controlPublic code

jev-mobile Android control loop

Author / team: Friedjof

Input: A user goal, semantic Android UI state and the set of currently valid actions.
Jev decision: Jev uses Choice to select the next step from actions supplied by code; it does not generate arbitrary coordinates or code.
Next action: The worker journals the mutation, acts on the device, observes again and uses separate checks to decide whether the task is complete or needs escalation.

Evidence limit: The flow needs an authorized USB-debugging device and TypeSafe API; UI context may leave the device. This site did not reproduce it on a phone, and risky actions and completion depend on the project's own approval and verification logic.

Original sources: GitHub

Computer usePublic code

TypeSafe computer-use assistant

Author / team: awlevin

Input: A user goal, screen OCR or accessibility state and actions allowed by the program.
Jev decision: Jev uses Choice to select an action kind, target control or site, and can use Noul to check whether typed text suits a field.
Next action: The executor drives the mouse and keyboard deterministically, then captures the next screen state before continuing.

Evidence limit: This beta controls a real desktop. Screen content goes to TypeSafe, and optional text generation uses another model. This site did not verify speed, cost or OSWorld results; users should start with a dry run.

Original sources: GitHub

Coding-agent supervisionPublic code

foreman

Author / team: thruwire

Input: A ticket, spec, or bug report plus factory evidence such as diffs and tests produced by Codex or OpenCode workers.
Jev decision: One Jev call returns parallel probabilities for implementation completeness, requirement satisfaction, test sufficiency, verification need, worker health, and human escalation.
Next action: Code decides to continue, steer, stop, retry, verify, or finish based on thresholds; Jev only supervises and never writes code.

Evidence limit: The repository states effectiveness depends on configured checks, evidence, thresholds, and models; this site read the code and docs without independently reproducing results.

Original sources: GitHub

Game agentPublic code

minecraft-agent

Author / team: rmalde

Input: A planning goal plus live state from a vanilla Minecraft server; a read-only Java sensor can report the exact dragon-head position.
Jev decision: GPT-6 Astra plans while Jev selects each player action; the author's best verified run used 131 Jev decisions and 35 Astra calls.
Next action: Selected actions are sent through the normal player protocol; game rules and entity state stay untouched.

Evidence limit: The 8m43s run is the author's best recording and dragon timings vary per run; recordings stay local and were not replayed by this site.

Original sources: GitHub

Game agentPublic code

typesafe-mario

Author / team: fhshaik

Input: Emulator telemetry and RAM parsed into compact JSON covering Mario's motion, jump arc, enemies, terrain, and past control results; no screenshots.
Jev decision: A Choice picks one of seven legal controller actions (noop, right, right_jump, …) and returns the full probability distribution.
Next action: The emulator advances several frames and the loop repeats; latency, probabilities, and confidence are logged to local JSONL.

Evidence limit: No ROM ships with the repo and a legal copy is required; the 8-frames-per-decision default is experimental, with no published completion benchmark.

Original sources: GitHub

Mobile agentPublic code

mobile-jev

Author / team: droidrun

Input: Screen state from a Mobilerun Android phone plus a natural-language goal.
Jev decision: Jev selects each step from available actions; the Uber demo completes nine actions in about 21 seconds, from opening the app to payment selection.
Next action: Actions run on a real phone through the Mobilerun API with execution traces and per-request latency; the sample task stops at payment selection.

Evidence limit: Timing comes from the author's recorded demo; device and Mobilerun charges are extra, no booking is completed, and this site did not rerun it.

Original sources: GitHub

Voice browser controlPublic code

jev-voice-browser

Author / team: Moritz Kremb

Input: Partial speech transcripts streamed from the Web Speech API plus an indexed snapshot of up to 100 elements on the controlled page.
Jev decision: Each partial transcript fires one Jev request with 9-11 questions on intent, target element, site, completeness, addressee, and destructiveness, returning in ~250-350 ms.
Next action: Code decides to act, wait, ask, or ignore; queries and URLs are extracted as candidate spans that Jev only picks verbatim — it never writes text.

Evidence limit: The microphone relies on Chrome/Edge Web Speech; latency and the ~$0.0002-per-call figure are the author's measurements.

Original sources: GitHub

RoboticsPublic code

jev-drone

Author / team: RomanSlack

Input: Depth and segmentation from the onboard camera, compressed by classical CV into five forward sectors and obstruction heights; Jev does no perception.
Jev decision: At 2.5 Hz one call asks three questions — a Choice of maneuver, a Score of risk, and a Noul on whether the target is truly lost; scene fingerprinting caches repeats (~110 calls per 65 s flight).
Next action: Tactical judgment is advisory; a 50 Hz safety reflex and a 500 Hz geometric controller hold veto power, for example climb is refused unless the measured obstruction top is reachable.

Evidence limit: A five-station course in MuJoCo simulation; figures come from the author's flight runs, not a physical drone, and were not replayed here.

Original sources: GitHub

Model routingPublic code

jev-codex-router

Author / team: 0xNatoshi

Input: A bounded decision state from the Codex session; the full canonical replay goes only to the executing model, never to Jev.
Jev decision: For every model call, including continuations after tools, Jev picks the model and thinking effort together, targeting sufficient capability without wasting quota.
Next action: Requests route through the embedded Codex Router fork to luna/terra/sol/astra; any Jev error fails open and traffic passes through unchanged.

Evidence limit: The README's ~60% saving is a backtest of 237 turns under an old policy, explicitly not measured quota saved nor evidence for the current policy.

Original sources: GitHub

Context compressionPublic code

jev-pruner

Author / team: Tamara Tran

Input: Bash stdout right after Claude Code runs it (outputs under 10,000 estimated tokens pass through) plus the task and session history.
Jev decision: Output is chunked and each chunk gets one noul — does any line still need to be available? A single needed line protects the chunk, including values earlier instructions depend on.
Next action: Unneeded chunks are dropped and the rest flows on untouched; errors, JSON/XML/diff output, whole-document commands like git diff, and recognized documents are exempt.

Evidence limit: Independent of the author's fast-jev-compaction; token counts are estimates, not exact tokenizer output, and compression was not measured here.

Original sources: GitHub

Graph retrievalPublic code

neo4jev

Author / team: jexp

Input: The outgoing relationships of the current Neo4j node (type, properties, target label/properties), with schema discovered live by introspection.
Jev decision: A Choice picks the next relationship while a noul asks whether the goal is reached, riding in the same call so each hop costs one round trip.
Next action: Probabilities feed a top-k beam search ranked by summed log-probability, and the path is rendered interactively with its neighborhood.

Evidence limit: Notebooks and the Streamlit app run against the public companies2 graph; without a key, failures show verbatim and clearly labelled stand-in answers drive the pipeline — never presented as TypeSafe output.

Original sources: GitHub

Agent tool reviewPublic code

pi-jev

Author / team: y0usaf

Input: Pending bash/write/edit calls from the Pi coding agent, plus what a command printed after it ran.
Jev decision: The gate bundles three nouls (destructive, exfiltration, beyond scope) and a four-level impact score into one request; an output judge adds two questions on secrets and failure class.
Next action: Shadow mode only notifies by default and can switch to pre-run confirmation; every error path fails open — a missing key, timeout, or 429 lets the tool call proceed.

Evidence limit: Thresholds (0.90/0.70/0.85/2.50) are the author's defaults; this layer does not replace host permissions or real security boundaries.

Original sources: GitHub

Video content analysisCode + author post

jevmeter

Author / team: ChetasLua

Input: Sentence-level transcript of any video plus a chosen preset (debates, earnings calls, podcasts, or pitches).
Jev decision: Each sentence is scored against the preset, flagging dodged questions, emotional appeals, self-contradictions, and hype; the author reports 99% held-out preset accuracy.
Next action: Results render into a postable 16:9 edit; a full debate costs about $0.05 to score.

Evidence limit: Accuracy and cost are the author's self-reported evals, not reproduced here; presets target mostly English audio and video.

Original sources: GitHub X

Terminal productivityPublic code

jev-shell-history

Author / team: mrnugget

Input: The half-typed command line and the last 100 distinct history entries.
Jev decision: A Choice ranks which history entry the input is most likely completing; a literal prefix match completes directly, otherwise a replace mode suggests the best fuzzy match.
Next action: A fish-style grey suggestion with its score appears after the cursor; press → or ^E to accept, with limits and thresholds configurable.

Evidence limit: Keystrokes can trigger API calls (gated by a 2-character minimum and thresholds) at the user's expense; the demo GIF uses fabricated history.

Original sources: GitHub

Tool callingPublic code

jev-chat

Author / team: w3cj

Input: The user's message, conversation state, and earlier tool results; only a TYPESAFE_API_KEY is required.
Jev decision: Choices pick which MCP tool to call, where each argument comes from, whether to confirm first, and the reply type; a noul checks whether fields like a due date are stated.
Next action: Code calls the tools and builds replies from their own data — no model writes text, so every value on screen is either typed by the user or returned by a tool.

Evidence limit: An inspector shows the full request, probabilities, and code actions for any reply; the bundled tool set is small and not a general chat replacement.

Original sources: GitHub

Browser extensionPublic code

typesafe-adblock

Author / team: Zachi

Input: Ad-shaped DOM candidates pre-filtered by code rules, compressed into compact JSON with tag, classes, link hosts, and standard IAB sizes.
Jev decision: One request per batch carries a noul per candidate — is this a paid advertisement? — returning one probability per element.
Next action: Elements with P(ad) ≥ 0.70 are outlined, shrunk, and removed; a MutationObserver catches lazy-loaded ads, capped at 30 candidates per batch.

Evidence limit: The author calls it a fun project, not a real ad blocker: it costs tokens per page, misses ads, eats non-ads, and does nothing about tracking or video ads.

Original sources: GitHub

Email triagePublic code

jevmail

Author / team: fazlerocks

Input: Gmail messages fetched with a single read-only gmail.readonly scope and only list/get-style methods.
Jev decision: Three questions per message: which of five trays (needs reply, updates, promos, sales, spam), a 1-5 urgency score, and whether a human wrote it to you.
Next action: Mail sorts into trays showing top-two probabilities, with corrections stored beside original answers in local SQLite; 1,000 emails take about a minute and around 3 cents.

Evidence limit: Read-only — it never sends, archives, or labels; speed and cost are the author's measurements through the Vercel AI Gateway.

Original sources: GitHub

Smart homePublic code

HA-Jev

Author / team: AboveColin

Input: House and sensor state, plus Noul/Choice/Score questions defined by the user in the UI or YAML.
Jev decision: Every question becomes an entity — a probability, an option with its distribution, or a scale value — while four actions (jev.noul, jev.choice, jev.score, jev.ask) answer inside automations.
Next action: Entities feed automations and Assist voice routing; the integration reports daily calls, input tokens, and estimated cost against a daily budget.

Evidence limit: A HACS custom integration whose author states it is not affiliated with TypeSafe; judgment quality depends on question design and automation outcomes rest on user config.

Original sources: GitHub

UI intent classificationPublic code

shapeshift

Author / team: anishfn

Input: Live typing in a single text box, such as "dinner with priya friday 8pm on zoom" or "split 2400 between 3".
Jev decision: One Jev call answers 14 parallel questions: which card the input should morph into (event, checklist, timer, bill splitter, color picker, poll, …) plus signals like "is it a video call?" or "is it urgent?".
Next action: Dates, amounts, units, and math are resolved by deterministic code; without a key or on API errors it silently falls back to a built-in keyword classifier and stays fully offline.

Evidence limit: The online key is read only server-side; the offline fallback means the default experience does not reflect Jev accuracy, and no A/B comparison was made here.

Original sources: GitHub

Agent evaluationPublic code

jevals

Author / team: Openlayer

Input: An agent trace (OpenAI-format messages and tool schemas; Anthropic content blocks and LangChain messages also pass directly).
Jev decision: One request returns eight parallel judgments — tool choice, used tool result, groundedness, scope, relevancy, completeness, indirect injection, and PHI.
Next action: One request per trace at a few thousandths of a cent in a few hundred milliseconds, cheap enough for every trace and the agent loop; backends include TypeSafe/Vercel, local Kev or Laya, or a plain LLM.

Evidence limit: Example figures come from the author's quickstart trace; the validity of each metric was not independently evaluated here.

Original sources: GitHub

Context compressionPublic code

winnow

Author / team: Ghaleb Dweikat

Input: Large Read, Bash, or Grep results in Claude Code, split into roughly 25-line blocks.
Jev decision: Each block gets one noul — is it needed for the current task? Only confident-no blocks are hidden; uncertain blocks and outputs that look like errors always stay.
Next action: Hidden blocks become a three-line stub: what was hidden, a one-line summary from a cheap model, and a key that restores the full text on demand.

Evidence limit: It leans on the judge's calibration, with an uncalibrated Claude Haiku adapter offered as a fallback; thresholds are configurable and savings were not measured here.

Original sources: GitHub

Chat copilotPublic code

jev-chat-jarvis

Author / team: 恸码奇点（jev-chat）

Input: The on-screen conversation captured on the user's own device — accessibility-tree reading on Android, window screenshots plus local OCR on Windows; only conversations the user can already see.
Jev decision: Jev judges the other side's intent and emotional tension and ranks candidates; a generative model drafts three replies, each shown with the win probability Jev assigned.
Next action: A translucent overlay shows the judgment and candidates with one-click copy/fill into the input box; sending always stays manual and transfers or red packets are never touched.

Evidence limit: Judgments run through OpenRouter or direct TypeSafe access with user-supplied keys; users are responsible for lawful screen reading, no eval data ships in the README, and this site did not test it.

Original sources: GitHub GitHub · Windows 版

Enterprise model routingAuthor post only

Glean offline expert routing pilot

Author / team: Tony Gentilcore 等 Glean 作者

Input: 751 historical requests with golden expert-route labels, using a three-expert simplification of the production router.
Jev decision: Jev chooses one of three predefined experts for each request, replacing the bounded selection step of the generative routing prompt.
Next action: The team compares choices with golden labels and its LLM router, then separately measures latency on 40 actual-transfer examples; the article does not claim deployment.

Evidence limit: This is an author-reported offline evaluation without public code or independent reproduction. The 8.1× median speedup comes from 40 transfer examples; data residency and operational guarantees remain open.

Original sources: X article TypeSafe X

Browser testingPublic code

jevwright browser business-flow tests

Author / team: Ice-Hazymoon

Input: Natural-language business steps, controls on the current Chromium page, and declared API requests and assertions.
Jev decision: Jev grounds each step to a control on the live page and makes bounded checks of visible state; it does not decide whether the test passed.
Next action: Playwright acts and records a semantic path for later model-free replay; requests, API/database assertions and code monitors determine pass or fail.

Evidence limit: Initial grounding or healing needs an OpenRouter/Vercel gateway key; replay does not. Code and CI are public, but costs and outcomes are author-reported; this site did not run a live-site test.

Original sources: GitHub Source code

Tax-document routingPublic code

IRS form-page classification with confidence gate

Author / team: kyotofin

Input: Text extracted from one PDF page plus repository-generated IRS form and page-kind options; code handles blank pages directly.
Jev decision: Jev Choice selects a form and one of seven page kinds, with a second choice for a few form families, returning probabilities.
Next action: Code emits a form ID, page kind and confidence; it gates downstream routing at 0.95 by default and leaves low-confidence handling to the caller.

Evidence limit: Limited to English federal forms. Scans need OCR, while state forms are only detected by kind. Page text goes to TypeSafe; accuracy, speed and cost are author-reported and were not remeasured or used for tax filing here.

Original sources: GitHub Source code

Game agentPublic code

NetHack legal-action selection

Author / team: statico

Input: The current NetHack terminal view, player state, and legal actions enumerated by code for this turn.
Jev decision: Jev uses Choice to pick the next step only from the legal-action list, without generating arbitrary keystrokes.
Next action: The project motor maps the selected action to keystrokes, then reads the resulting screen for the next turn.

Evidence limit: The default run needs a local NetHack build and a paid TypeSafe API key; source also supports a compatible local server. The repository shows runs and decision logs, but this site did not verify ascension, win rate, or cost.

Original sources: GitHub Source code

Mobile testingPublic code

jevvium mobile acceptance-test generation

Author / team: AndresCarreonDiaz

Input: A YAML acceptance goal, the current Appium screen and actionable controls, and optional explicit assertions.
Jev decision: In one request, Jev uses Choice to select the next action, Noul to judge goal completion, and closed choices for field values.
Next action: Appium performs the action; once the goal and assertions hold, the tool writes a WebdriverIO test with fixed selectors and validates it through model-free Appium replay.

Evidence limit: Requires Appium, a device or simulator, and a TypeSafe key. Without explicit expect assertions, a pass may rest only on the model judgment; author-reported timings and pass rates were not reproduced here.

Original sources: GitHub Source code

Retrieval-augmented generationPublic code

RAG passage screening and answerability gate

Author / team: MersivMedia

Input: Document paragraphs before indexing, a user query, and candidate passages retrieved from a vector store.
Jev decision: Jev makes bounded judgments on whether paragraphs or passages are boilerplate, instructions aimed at AI, relevant, contradictory, or sufficient to answer.
Next action: Code applies thresholds to drop or quarantine paragraphs, rank and retain evidence, and build an answer prompt only when the gate passes; otherwise it abstains.

Evidence limit: Requires a vector store and embedder; without a Jev key it can degrade to plain vector ranking. Recall, injection screening, and cost figures in the README are author-reported and were not remeasured here.

Original sources: GitHub Source code

Sales-data retrievalAuthor post only

Rox offline sales-retrieval evaluation

Author / team: Rox

Input: Seventy-five production-like sales queries and candidate passages from transcripts, email, CRM, news, and documents.
Jev decision: Jev Score rates each candidate passage on four levels from not relevant to directly relevant.
Next action: The team reranks candidates by score and compares the offline results with GPT-5 Mini reranking and labels from another model.

Evidence limit: Only author posts and experiment images are available, with no public code or sample set. The 75-query evaluation is small; speed, cost, and accuracy are author-reported, not independently reproduced or proof of deployment.

Original sources: Author X Method thread TypeSafe X

Business-risk monitoringCode + author post

Profile-based risk monitoring and escalation

Author / team: Edward Irby / youdotcom-oss

Input: A user-defined risk topic, locations, and policy triggers plus current You.com highlights and sources.
Jev decision: Jev Noul judges threat and query proposals, Score rates retrieved evidence, and Choice selects low, medium, or critical severity.
Next action: Code records a clean sweep or starts a budgeted deep dive; Qwen proposes queries and drafts prose while the program persists a source-linked report and judgment probabilities.

Evidence limit: The author reports three live sweeps, but costs, report quality, and factual conclusions were not independently checked. External search and model services receive the relevant context.

Original sources: GitHub Author X Source code

Knowledge-base write reviewPublic code

Offline knowledge-write admission evaluation

Author / team: Nicia

Input: An incoming record, five to nine accepted records, and the old version of an edited record, evaluated on 85 synthetic cases.
Jev decision: Jev Choice classifies each comparison as contradictory, restated, or compatible and each edit as correction, rewording, addition, or meaning change.
Next action: Evaluation code aggregates probabilities and simulates automatic admission only when risk is confidently low; otherwise it sends the write for human review and compares other decision models.

Evidence limit: All 85 cases use fictional organizations. The author-reported accuracy, order stability, and latency were not remeasured here and do not establish production write-admission quality.

Original sources: GitHub Source code

Voice desktop assistantPublic code

Wisp voice-to-desktop action routing

Author / team: duketopceo

Input: Push-to-talk transcript, recent conversation, and bounded context such as the active window.
Jev decision: Jev through OpenRouter Decisions uses Choice to select app launch, tool, agent, answer, or clarification and to identify a target.
Next action: The daemon invokes desktop tools or starts a coding agent according to risk tier; a separate chat model writes ordinary answers, and shell actions require confirmation.

Evidence limit: Primarily targets Linux Omarchy/Hyprland, with an author-provided macOS port. It needs microphone access, transcription, and an OpenRouter key; voice context may leave the device. This site did not reproduce desktop actions.

Original sources: GitHub Source code

Coding-agent result verificationPublic code

claude-referee completion-claim check

Author / team: ismaildasci

Input: Test or lint output from Claude Code and explicit completion criteria supplied by the user.
Jev decision: Code first parses exit codes, skipped tests, and summaries; Jev then uses a Noul for each criterion to judge whether the evidence supports it.
Next action: The CLI reports met, unsure, or missing and keeps a local receipt so the user can rerun checks or inspect missing evidence.

Evidence limit: The automatic Stop hook currently records in shadow mode; active blocking is planned. Order-sensitivity and cost measurements are author-reported and unverified here, so this is not evidence that false completion claims are already blocked automatically.

Original sources: GitHub Source code

Long-document retrievalCode + author post

PageIndex and Jev hierarchical page search

Author / team: PageIndex / VectifyAI

Input: A user question and a PageIndex tree built from a PDF, with node titles, summaries, page ranges, and page text.
Jev decision: Jev Choice picks likely sections and pages level by level, then Noul checks whether candidate pages contain answer information.
Next action: Code narrows candidates along the tree and returns pages, text, and the judgment trace for inspection; it does not generate a final answer.

Evidence limit: Requires TypeSafe and PageIndex API keys, and uploads the PDF to PageIndex cloud. Demonstrations and retrieval quality were not independently reproduced; returned pages still need source review.

Original sources: GitHub Author X Source code

Coding-agent permission decisionsCode + author post

Claude Code auto-mode permission precheck

Author / team: Madison Rickert

Input: A pending Claude Code auto-mode tool call, recent user messages, and the project path.
Jev decision: Jev answers eight Nouls in one request about user intent, risks, and approval-steering text; code thresholds yield allow, deny, or defer.
Next action: Clearly allowed calls bypass the built-in classifier, clearly risky unrequested calls are denied, and uncertain calls return to Claude Code built-in classification.

Evidence limit: Requires Claude Code auto mode with mods. Pending commands and recent messages may go to TypeSafe, including inline secrets missed by filters. Model errors defer to the built-in classifier; author-reported latency and safety samples were not reproduced and are not a general security guarantee.

Original sources: GitHub Author X Source code

Scientific computingPublic code

Bounded rarefied-gas flow planning

Author / team: cfdgasman

Input: A plain-language description of gas flow between plates, with quantities and units first extracted by code.
Jev decision: Jev Choice selects flow type, geometry, gas, and quantity roles from closed options; code uses confidence to run, ask for clarification, or decline.
Next action: Deterministic code computes the Knudsen number, selects an applicable fluid or kinetic solver, and returns shear stress or flow rate with units.

Evidence limit: Limited to the supported parallel-plate Couette and Poiseuille problems. The author solver validation and Jev costs were not reproduced; recorded answers can replay offline, so not every demo run is a live Jev call.

Original sources: GitHub Source code

Agent memory retrievalPublic code

Batch reranking agent memories with Jev

Author / team: kitfunso

Input: A user query and up to 40 pre-retrieved local memories, truncated and passed through a secret redactor.
Jev decision: In one System One call, Jev answers one Noul per candidate about whether it helps answer the query and returns relevance probabilities.
Next action: Code reranks the memories for the downstream answer step; request failure or incomplete answers fall back to a local cross-encoder.

Evidence limit: Jev reranking is opt-in and sends query and memory text to TypeSafe. Author-reported ranking gains on two corpora were not reproduced; their evaluation did not show better final answers than a free reranker, and top score does not prove answerability.

Original sources: GitHub Source code Author evaluation

Creator content researchPublic code

Jev shortlists social content for creator research

Author / team: SeeYangZhi

Input: Posts become sourced text evidence packets from transcripts, on-screen text, captions, comments, and metrics.
Jev decision: Jev answers typed fixed-rubric questions for each post to decide whether it belongs in the research shortlist.
Next action: Code applies thresholds and diversity selection, then sends survivors to Claude to explain patterns and draft concepts.

Evidence limit: The repository says backend and fixture flow are implemented while the frontend is planned. This site checked code and README only, not live platform integration or selection quality; Jev and Claude require credentials.

Original sources: GitHub Source code

Coding-agent quality feedbackCode + author post

Jev checks team rules after coding-agent edits

Author / team: Chris Korhonen

Input: Code just edited by a coding agent and repository-configured team rules.
Jev decision: TypeSafe Jev answers Nouls for configured rules, returning probabilities of violations worth flagging.
Next action: A post-edit hook reports likely violations to the agent for repair and records checks; service failures let the edit proceed.

Evidence limit: Cloudflare Clef is optional, with accuracy not yet measured by the author; the demo includes an illustrative scene. README latency, cost, and violation reductions are author results, unverified here, and do not replace deterministic lint or review.

Original sources: GitHub Source code Author X

Note-agent permission reviewPublic code

Jev review of SiYuan AI tool calls

Author / team: wmy2981

Input: A pending SiYuan AI tool name, arguments, and effects plus the user request and agent-stated intent; long fields are truncated with omissions marked.
Jev decision: In one request, Jev answers two Choices about user authorization and action impact, plus a Noul about self-authorizing text inside the pending action.
Next action: Code validates answers and applies confidence thresholds for allow, deny, or ask; outside advisory mode it acts on the native approval card and leaves uncertain calls to the user.

Evidence limit: Requires an enabled decision model in SiYuan and auto-review selected for the session. Tool arguments and user requests may be sent to the provider; authorization decisions can be wrong, and this site did not test live approvals.

Original sources: GitHub Decision request Policy and action

Board-game decisionsPublic code

Jev selects legal moves across seven board games

Author / team: tripodxu

Input: The current board state, side to move, legal moves enumerated by the engine, and deterministic tactical facts.
Jev decision: Jev Choice provides probabilities for candidate moves; code accepts only options matching the engine legal moves.
Next action: A tactics layer can override for wins or defenses; otherwise code takes the top move or samples among top options, then the game engine executes and records it.

Evidence limit: The repository also has mock, random, and Rapfi modes, so not every game calls Jev. Live-site operation and win rates are author claims; this site checked source but did not replay matches.

Original sources: GitHub Source code

Game agentPublic code

Jev macro goals and actions in Factorio

Author / team: jevplays-games

Input: A game snapshot with nearby resources, inventory, machine state, and position; code first enumerates actions possible now.
Jev decision: In one System One request, Jev uses Choices for goal and next action, a Noul for stuck state, and a Score for urgency.
Next action: Code checks that the action remains in the candidates and meets a confidence floor; otherwise it uses a deterministic fallback, then reads and records the post-action state.

Evidence limit: The offline no-key mock is rule-based, not Jev inference; native Factorio/FLE needs a dedicated resettable world. The basic loop records post-action state but has no full postcondition check; gameplay was not reproduced here.

Original sources: GitHub Questions Decision loop

Model-answer quality feedbackPublic code

Bounded Spring AI answer refinement with Jev

Author / team: Spring AI Community

Input: The original request, a candidate model answer, and tool-call or retrieval context visible at the advisor position.
Jev decision: JevJudge asks Noul, Choice, or Score questions per criterion; code thresholds yield pass, fail, or inconclusive. Deterministic Java predicate checks run locally.
Next action: The advisor rebuilds feedback from the original request and retries failed answers within a budget, then returns a passing answer or, by configuration, the best candidate or an error.

Evidence limit: A community Spring AI extension. Transient judge failures may return an unjudged answer by default, and advisor order determines whether retries rerun tools. Refinement is non-streaming; this site did not call the API or prove better answers.

Original sources: GitHub Judge contract Advisor source

Card-game agentPublic code

Jev choices validated by a Magic game engine

Author / team: Vincent Bons / wingedsheep

Input: A masked snapshot from the current player perspective, deck context, and engine-provided affordable legal actions; opponent draws from debug logs are excluded.
Jev decision: OpenRouter Jev uses native Choices in stages for plays and details such as targets, as well as mulligans and drafts; only supplied option IDs are accepted.
Next action: Code constructs an action and validates it against the authoritative engine. Rejection gives Jev one correction attempt; continued failure or exhausted budget falls back to built-in AI.

Evidence limit: Jev is currently limited to local development mode and requires an OpenRouter key. The project has rules and alternative model modes, so not every game uses Jev; full Magic coverage, match performance, and latency were not verified here.

Original sources: GitHub Controller source Jev client

Observability and control loopsCode + author post

Reflex: telemetry-guided circuit breaking and recovery probes

Author / team: Datadog Labs / @ArunPar10

Input: Circuit phase and revision, short/long Datadog windows of failures, timeouts, latency and queue data, plus optional Toto forecasts.
Jev decision: A single Choice asks Jev to recommend Open, Probe or NoChange. Forecasts are evidence and cannot replace recovery probes.
Next action: The executor checks revisions, telemetry freshness, cooldowns and state constraints before applying a transition. Code closes the circuit after five successful probes, reopens it on a failed probe and leaves it unchanged on inference failure.

Evidence limit: Verified from the author’s simulator and SDK integration code. This site did not run Datadog/Toto/Jev or validate production reliability or outcomes.

Original sources: GitHub Jev controller X

Monitoring alert triagePublic code

Alertmanager: triage annotations that preserve notifications

Author / team: gbesse

Input: Alertmanager group labels such as alertname, service and severity, with summary/description annotations. Truncated groups or groups over ten alerts go directly to review.
Jev decision: Jev chooses incident, routine or other; code maps other or a probability below 0.9 to review.
Next action: The relay forwards every original notification with a jevDecision annotation. It does not silence, inhibit, resolve or drop alerts; Jev failures are forwarded as review and downstream delivery failures return HTTP 503 for retries.

Evidence limit: The author reports an API exercise with synthetic input and no live Alertmanager instance. This site reviewed source and README only, without testing production alerts, end-to-end delivery or classification quality.

Original sources: GitHub Jev API adapter Relay

Predictive keyboard experimentPublic code

Jevons Talking: composing text through finite keyboard choices

Author / team: kmosher

Input: A question, partial reply, recent picks and a menu of WordNet predictions, letters, punctuation, backspace and stop keys.
Jev decision: Each step uses a Jev Choice to select a key from the current menu, with optional Noul checks for completion or corrections.
Next action: Code appends words or characters, updates prefix predictions, applies backspace or stops, and records probability traces. A step budget bounds the loop.

Evidence limit: The experiment is constrained by its dictionary and menus. Repository transcripts are author samples; this site did not call the API, validate reply quality or certify assistive communication use.

Original sources: GitHub Source

Language and track puzzlePublic code

Railroad Route: one sentence controls mine-cart switches

Author / team: vinicius-francozo

Input: An English or Portuguese player sentence, the edited track board and all finite switch questions for the level.
Jev decision: One Jev request batches Choice exits, Noul gates and Score levels; code maps them to switch results using thresholds or rounding.
Next action: The backend validates answers, simulates the cart square by square and reports arrival, a wrong tunnel or derailment, then scores the route, decision margins and track usage.

Evidence limit: A five-level game. Author live API and latency results, reference solutions and replay tests were not reproduced here and do not establish general physical planning ability.

Original sources: GitHub Source Source

Digest pre-filteringPublic code

sift: filter items and sources before generating digests

Author / team: BeforeLanding

Input: A configured interest profile, collected items and per-source summaries.
Jev decision: The real Jev backend batches item relevance Scores and uses Nouls to judge whether sources merit reports.
Next action: Configured thresholds filter inputs before bilingual LLM report generation. Failed or uncertain items are retained, and an emptied source keeps a small top-ranked fallback.

Evidence limit: Real SDK and mock paths are separate. This site reviewed code only and did not validate author savings, published reports or recall of filtered information.

Original sources: GitHub Source Source

Community message moderationPublic code

JevBot: observe Discord detections before policy enforcement

Author / team: OGZamasu

Input: A Discord message, recent messages from the same author, channel rules and prior strikes.
Jev decision: A Jev Choice labels spam, legitimate or uncertain; code then applies spam probability, confidence and deterministic-rule checks.
Next action: New servers start in Observe and log detections. Uncertainty goes to review. Configured enforcement can warn, delete or time out after rechecking settings, with failed actions recorded and no automatic bans.

Evidence limit: Requires Discord, Cloudflare and TypeSafe configuration. This site did not connect to a live server or validate access controls, false positives or actual deletions.

Original sources: GitHub Source Source Source

Job-search relevanceAuthor post only

HiringCafe: job relevance scoring for queries and resumes

Author / team: Hamed Nilforoshan / HiringCafe

Input: A user search query or resume paired with a job description.
Jev decision: The author reports Jev rating relevance on a 1–10 scale and comparing it with other models and team annotations.
Next action: The author says the judgments support HiringCafe job search and resume matching, with evaluations for both relevance tasks in the thread.

Evidence limit: Author posts and a TypeSafe recommendation only, without inspectable source. The 500 team-labeled samples, user scale, costs and outcomes are author reports; this site did not obtain data, reproduce evaluation or infer the API request schema.

Original sources: Author post Matching use TypeSafe recommendation

Transaction classification prototypePublic code

Jev accounting: transaction suggestions with a review CSV

Author / team: darrentmorgan

Input: Transaction descriptions, signed amounts and currencies from CSV, with fixed illustrative account categories.
Jev decision: A Jev Choice selects a category. Code checks its probability and routes values below 0.85, missing probabilities, invalid responses or Unassigned to review.
Next action: Keeps original transactions and order, displays suggestions, assignments and review reasons, then exports CSV without writing to an accounting system.

Evidence limit: A v0.1 prototype with eight synthetic examples. Author smoke tests do not establish accounting accuracy or savings; this site did not submit real transactions, call the Gateway or reproduce accounting outcomes.

Original sources: GitHub Source Source

Semantic map explorationPublic code

mappity: probabilistic place matching on a map

Author / team: kortexa-ai

Input: A natural-language wish, fetched place types and facts, with optional street context.
Jev decision: Jev classifies the bounded request and place types, then uses Nouls for place/street relevance and selects an explanation from existing facts.
Next action: Code performs geographic lookup and hard-constraint filtering, combines place/street probabilities when needed and highlights matches with the selected facts.

Evidence limit: Verified from Jev SDK integration and author demonstrations, without testing live map recall, location accuracy or outcomes. Optional Shingi is a separate model whose calibration cannot be assumed valid for this app.

Original sources: GitHub Source Source

Semantic text operationsPublic code

ex-regex: find and replace source spans by meaning

Author / team: nothans

Input: Original text, enumerated candidate spans and a natural-language condition such as whether a sentence requests a refund.
Jev decision: Jev returns typed semantic judgments and probabilities for candidates, while the library distinguishes match, non-match, uncertainty and call failures.
Next action: The Python API returns verbatim spans with offsets for finding, extraction, replacement or splitting, with caching, replay and budget limits in code.

Evidence limit: Verbatim slicing limits invented strings but does not guarantee correct matches. Author synthetic evaluations and costs were not reproduced; model quality, missed spans and reliable redaction were not validated here.

Original sources: GitHub Source Source

Stack and vulnerability informationPublic code

Vulnder: stack judgments assist vulnerability matching

Author / team: fullymiddleaged

Input: A user-described software stack, parsed components and candidate product names.
Jev decision: Jev Choices infer scale and hosting, while Nouls assess injection, product fit and internet exposure; missing answers remain unknown.
Next action: Code uses judgments to assist product resolution and exposure flags, then matches CVEs. Public exploitation signals and deterministic heuristics compute priorities for page, JSON or Atom output.

Evidence limit: Base parsing remains available on Jev failure, and stack URLs are shareable. This site did not validate vulnerability coverage, product matches or risk calibration; rankings are this project’s heuristic output.

Original sources: GitHub Source

Coding-assistant input previewAuthor post only

Jev Skill Typeahead: preview skill probabilities before sending

Author / team: Daniel San / @dani_avila7

Input: A prompt being typed and the finite set of installed skill candidates.
Jev decision: The author says Jev predicts the skills Claude is most likely to invoke and estimates their probabilities.
Next action: The UI shows predictions before the request is sent so users can understand or adjust prompts; the post also links public source.

Evidence limit: Author post and demo description only. Source and prediction accuracy were not reviewed in this run; no API primitive was inferred and predicted probabilities do not guarantee actual skill execution.

Original sources: Author post Author source link (not reviewed)

Semantic table filteringPublic code

VibeFilter: filter table rows by a natural-language condition

Author / team: vibefilter

Input: A user-written condition and selected text columns from rows remaining after other SQL filters.
Jev decision: Batched Jev Nouls judge each row against the condition. Code reads probabilities and applies a configurable threshold, defaulting to 0.8.
Next action: Caches condition/text scores and displays passing rows with an optional score column, asking for confirmation before large unscored sets.

Evidence limit: MIT community plugin with inspectable TypeSafe calls and score consumption. This site did not install it, call the API or reproduce author demo timing, cost or match quality.

Original sources: GitHub Source Source

README claim-verification prototypePublic code

README Clew: classify claims before deterministic verification

Author / team: earlgreyhot1701D

Input: Segmented README lines, candidate symbol names and repository dependency/file snapshots.
Jev decision: Jev via Glasser chooses a bounded claim type and, when necessary, a candidate name; a confidence gate retains uncertain results.
Next action: The live scan passes answers to deterministic dependency, command, environment-variable and reference verifiers to build supported, contradicted or unverifiable findings; a manual evaluation entry also calls the live model.

Evidence limit: Included after live modules appeared in this snapshot; mock paths remain for offline tests and the full extension/web app is still in development. Paid evaluations and complete product usability were not verified here.

Original sources: GitHub Source Source Source

Browser reading cuesPublic code

Attention Vaccine: writing-technique cues while reading

Author / team: nevrs

Input: Length-limited visible post text or article openings on permitted sites, with bounded writing-technique questions.
Jev decision: Batched Jev Nouls assess wording such as inflammatory cues, scam-style inducements or unsupported generalizations, combined with per-check thresholds and deterministic checks.
Next action: The extension adds cues to matching content, exposing original questions, probabilities and explanations on user interaction, with caching and daily call limits.

Evidence limit: Judges wording rather than factual truth; text on enabled sites is sent to a model backend. The extension, API, author evaluations and permission-exclusion privacy behavior were not independently tested here.

Original sources: GitHub Source Source Source

Household load-scheduling prototypePublic code

Heliotrope: appliance importance scores assist load ranking

Author / team: StellarieX

Input: Appliance names and kinds, power, completion deadlines and flexibility windows.
Jev decision: Batched Jev Scores rate household importance against a finite rubric; code uses answers only when they meet a confidence gate.
Next action: Code combines importance with urgency, power and flexibility to rank loads for scheduling, explicitly labeling heuristic/mixed results on missing, failed or low-confidence model paths.

Evidence limit: Mathematical scheduling constraints remain in code and project carbon intensity is a proxy estimate. Model calls, appliance control, meter data and energy/emissions savings were not validated here.

Original sources: GitHub Source Source

MCP tool-routing benchmarkPublic code

ToolDiscoveryBench: choose an MCP tool or abstain

Author / team: SarathChandraBellam

Input: A task request, finite tool catalog, server descriptions and tool descriptions.
Jev decision: Jev Choices return probabilities over tool/server candidates. With NONE or a separate fit question, code compares probabilities within the same question to decide abstention.
Next action: Flat, factored or hierarchical routers return rankings and abstention for evaluation against baselines and reports, without directly executing selected tools.

Evidence limit: Measures discovery rather than complete agent success; gold tools were picked by coding assistants. Author accuracy, latency and cost were not reproduced, and other backends are not reported as Jev.

Original sources: GitHub Source Source

CS 1.6 game experimentPublic code

csgojev: choose the next game move from legal state-machine actions

Author / team: vigneshshanmugam

Input: Game observations including distance, sight, footsteps, health and time, with legal actions currently offered by XState.
Jev decision: A Jev Choice selects a next move such as peeking, stopping, retreating or waiting; code checks that the answer belongs to the offered set.
Next action: A TypeScript sidecar passes the selection to the state machine and game engine, which own movement, aim and physics, with comparisons against other policies.

Evidence limit: Uses mocks without a key, and the author has not shown superiority over the best hand-written script. Game/model runs and author timing/win rates were not reproduced. Whole-repository licensing is unconfirmed, so it is not listed as an open-source project.

Original sources: GitHub Source Source

Procedural service-agent examplePublic code

question-kit: closed judgments drive a pizza-counter workflow

Author / team: Engid

Input: Order/change/menu conversations with a finite menu, order records, tools and written procedure steps.
Jev decision: Jev reads bounded intents, menu/order candidates, required slots and confirmations, with uncertain readings routed to clarification or handoff instead of immediate action.
Next action: Code follows the procedure and returns tool calls; the example register updates the order and reports results, with replies rendered from templates rather than a generative model.

Evidence limit: An alpha library with a simulated register rather than real payment or kitchen wiring; fake/replay modes distinguish live Jev. Demo/API runs and order accuracy were not reproduced here.

Original sources: GitHub Source Source Source

GitHub label-classification prototypePublic code

DeciLabel: add Issue and PR labels supported by evidence

Author / team: EvanProgramming

Input: Issue/PR titles, bodies, bounded diffs with coverage warnings, existing repository labels and occupied exclusive groups.
Jev decision: Independent labels receive Nouls and exclusive groups receive Choices with none; code checks probabilities, the default 0.70 threshold and a 0.20 winning margin, abstaining on missing or malformed answers.
Next action: Rechecks item snapshots, label definitions and maintainer-removal history before adding labels only, without deleting, replacing, creating labels or running contributor code.

Evidence limit: Real API wiring is inspectable, but the author explicitly lacks live quality verification and 24 examples do not establish calibration. GitHub history checks and additions are not atomic; this site did not install the Action or alter external labels.

Original sources: GitHub Source Source Source

Dependency-update reviewPublic code

depgate: dependency-update merge, review and hold decisions

Author / team: samiulhuda360

Input: Release notes, repository usage, CI status and advisories for Dependabot/Renovate updates.
Jev decision: One Jev request asks a triage Choice, risk Score and four Nouls about breaking changes, repository impact, security fixes and runtime changes.
Next action: Code applies configuration, confidence, risk, CI and version constraints for comments, labels and review; eligible configured paths can approve and enable GitHub auto-merge, while dry-run does not write.

Evidence limit: Author evaluations and team stories are not independently verified production outcomes or safety guarantees. This site did not call Jev, connect user repositories, send notifications or perform approvals/merges.

Original sources: GitHub Source Source Source Source

Goal-based text filteringPublic code

skimmer: keep source chunks and list items relevant to a goal

Author / team: dorkitude

Input: A goal, overlapping chunks from pages/files and original-format list items.
Jev decision: One Jev Noul relevance question per chunk/item, batched to context budgets, with code parsing relevance probabilities against configurable thresholds.
Next action: Returns kept source text with paths/line ranges or lists in their original format/order; unjudged items from partial failures are kept by default, while total request failure reports an error.

Evidence limit: Verbatim preservation does not guarantee recall, and optional caps can trim even unjudged chunks. Author savings/quality were not reproduced and real workspace materials were not sent to the model here.

Original sources: GitHub Source Source Source

Coding-agent model routingPublic code

QQ: route tasks among authorized models and reasoning efforts

Author / team: retsu-AI

Input: A bounded masked task with configured, authorized and authenticated model/effort metadata.
Jev decision: A Jev Choice selects from at most 32 model/effort combinations, with code validating candidates, response contracts, confidence and winning probability; the latter gates are both 0.7.
Next action: The runtime recompiles and validates a selected route before execution, retaining the configured model when disabled, timed out, malformed, uncertain or unavailable, while honoring explicit selections.

Evidence limit: Optional routing is disabled by default. The actual TypeSafe POST and runtime wiring were located today, resolving a previously unverified lead. Agent runs, task quality, savings and full approval safety were not independently validated.

Original sources: GitHub Source Source Source

Official customer-memory examplePublic code

Official memory example: customer facts assist later ticket routing

Author / team: TypeSafe AI

Input: A current ticket, customer ID and previously saved tickets/answers for that customer.
Jev decision: A Choice routes the ticket, then a Noul judges whether the original request and answer contain lasting customer facts worth retaining.
Next action: Code stores tickets/answers by customer ID in a Python dict when the memory probability reaches 0.5, injects saved memories into later state and returns the routing answer either way.

Evidence limit: An official toy example with two fictional customers and six later tickets. The 0.5 threshold needs evaluation, and a dict is not production persistence or retention management. Results are official reports, not independently reproduced here.

Original sources: Official cookbook Official replay cache

Browser operationsPublic code

ego-jev: closed judgments drive multi-step browser flows

Author / team: Kim Jisub / kimjisub

Input: Current bounded page controls, a goal, caller-provided values and visible-state requirements.
Jev decision: Jev judges actions, target elements and supplied values; Nouls check requirements and a final verification rechecks visible goal completion.
Next action: Code acts through ego, refreshes page snapshots and continues the loop, returning actions and completion/uncertainty status.

Evidence limit: Requires ego/macOS. Irreversible-action options and source checks are not independently verified authorization guarantees. Page context goes to the model; author timing/success examples and real-account/form actions were not reproduced here.

Original sources: GitHub Source Source

Music-notation experimentPublic code

MIDI quantization: combine note-value probabilities with bar constraints

Author / team: ysetbon

Input: Pitches, onset times, gaps, key durations and time signature from one bar of piano MIDI.
Jev decision: One Jev Choice per onset returns probabilities over finite whole, quarter, dotted, triplet and other note values, with bounded initial-rest options.
Next action: Code uses dynamic programming to find a bar-length-compatible sequence for notation/comparison, falling back to per-item top probabilities when no exact fill is feasible.

Evidence limit: Author evaluation covers only 30 single bars with post-hoc threshold selection, not full-piece quality. Licensing is unconfirmed, so this is a code case only. Performance data, model calls and accuracy were not reproduced here.

Original sources: GitHub Source Source

Outing-planning prototypePublic code

Bayes: choose a tentative itinerary or request more research

Author / team: jimador

Input: Confirmed outing needs/preferences, map/site clues, code-generated itinerary alternatives and open questions.
Jev decision: With the Jev engine selected, TypeSafeModelFactory makes a Choice over bounded alternatives and research, with typed evidence/fit judgments.
Next action: Code displays a selected tentative plan, sources and gaps, returning clarification/research when needed without automatic bookings or an unbounded research loop.

Evidence limit: Defaults to local rules with separate remote-model/map consent. Map tags/site snippets do not prove current hours or traffic. Snapshot dependencies and author comparisons were not reproduced, and other engines are not reported as Jev.

Original sources: GitHub Source Source

Review-analysis casePublic code

Review insights: Jev classification before coded issue aggregation

Author / team: ethangrogan757

Input: Deduplicated review text in batches of up to five, with bounded topic, intent, severity and sentiment rubrics.
Jev decision: Jev Choices/Scores return four labels and probabilities, validated in code against IDs, allowed labels and output contracts.
Next action: Code saves results, reuses exact duplicates and quarantines unfinished/invalid rows; completed records feed deterministic severity-sum rankings before another model writes an evidence-linked memo.

Evidence limit: Only part of the full source was classified; pending rows are not counted as classifications. Sample quality, costs and product recommendations are author results. Licensing is unconfirmed, and this site did not copy review data or run the pipeline.

Original sources: GitHub Source Source

Email-triage examplePublic code

Two-stage email judgments: handling signals and reply labels

Author / team: Ankit Kalluraya

Input: A description of the email sender, subject and body.
Jev decision: First-round six-way Choice, urgency Score and reply/human Nouls; when code permits, a second round selects four tones, six intents and an auto-processing probability.
Next action: Spam/promotions return archive; notifications/newsletters return mute. No-reply mail skips round two. Others return flag_human, auto_draft or suggest_reply labels, without prose or sending.

Evidence limit: Python/jevlang example; human review gates after round two, and labels do not perform mailbox actions. The 0.5/0.60/0.85 thresholds are author defaults, and bodies reach the model. Not run or calibrated here.

Original sources: GitHub Source Source Source

Agent memory retrievalPublic code

OptChat: recover original chat records through a summary tree

Author / team: ericjuta

Input: A user question, binary-summary view lines and child summaries.
Jev decision: When the OMP judge role is Jev, per-line Nouls find likely answer ranges, then a Choice selects first/second at each level.
Next action: Code descends to one original record and returns its path and first 8KB, with zoom for the rest. Low relevance, failure and timeout return explicit outcomes.

Evidence limit: The role may use other models, so not all runs are Jev. Synthetic experiments measure navigation, not real Jev accuracy. Linux/Bun/OMP18.9+; licensing is unconfirmed, so this is a code case only and was not run here.

Original sources: GitHub Source Source

Monitoring-notification experimentPublic code

Alert routing: choose a notification channel with label fallback

Author / team: Starttoaster

Input: A scrubbed alert-group summary with titles/descriptions, severity, hosts and duration.
Jev decision: A Jev Choice judges page now versus informational; a separate 0–4 urgency Score is logged only.
Next action: Code checks confidence and P(page now) to choose a Discord channel. Low confidence, missing keys, timeouts and errors use severity=critical routing, while resolutions reuse the in-memory channel.

Evidence limit: Experimental receiver; sticky state is lost on restart. Thresholds need local alert evaluation, and model fallback does not guarantee delivery. Source has dry-run/synthetic tests; no deployment, model calls or notifications were made here.

Original sources: GitHub Source Source

Game-decision experimentPublic code

Minecraft: feasible action menus and competing turn claims

Author / team: mrubens

Input: Current game telemetry, goals, action costs/gains and feasible survival, food and work claims.
Jev decision: TypeSafe Jev uses bounded Choices/decision trees for actions and turn_priority, without generating gameplay code; probabilities, stale answers and calls are recorded.
Next action: Code executes menu items through Mineflayer, then rejudges after harm, failure, changed state or wait expiry. Most questions pause and retry during outages.

Evidence limit: Bodily-physics questions have coded exceptions; not every action is model-only. The author has not beaten the game. Figures such as 15/40 Nether entries and billing are historical author observations, with evolving code; the game was not run here.

Original sources: GitHub Source Source Source

Technical-troubleshooting evaluation prototypePublic code

Technical troubleshooting: separate diagnosis, remediation and resolution

Author / team: elioli983

Input: User symptoms/evidence, structured state from another model and validated research integration.
Jev decision: Jev Choices select fault domain/next action, Nouls separately judge diagnosis, remediation readiness and resolution evidence, and a Score assesses urgency.
Next action: Code constrains effective actions through lifecycle, compatibility prerequisites and safety checks, then another model writes advice and the case is saved. Attempted fixes and verified resolution stay separate.

Evidence limit: Windows development/evaluation build; advice does not automatically repair devices. Official TypeSafe and custom gateways are distinct. Offline tests, encryption and heuristics do not prove diagnosis accuracy or comprehensive security; no real case data or model calls were used here.

Original sources: GitHub Source Source Source

Job-seeker self-check experimentPublic code

Resume self-check: turn bounded fit signals into an explainable score

Author / team: dphbfs

Input: A full job posting and resume, with optional extracted requirements and evidence units.
Jev decision: One Jev request uses a Score for role match and Nouls for insufficient experience and a clearly unmet condition, retaining the model and signals.
Next action: Code combines fitted weights into a 0–100 Match Score and discounts by blocker probability. CLI/MCP returns the score, with separate per-requirement coverage and evidence outputs.

Evidence limit: For job-seeker self-check, without automatic hiring. Agreement fitted against a generative model is not objective ability or hiring accuracy. Author errors, timing and costs were not reproduced; resume text reaches the provider, and no real resumes or model calls were used here.

Original sources: GitHub Source Source Source

Official live-chat examplePublic code

Official chat filtering: hide, blur or highlight after classification

Author / team: TypeSafe AI

Input: A game name, stream title and one chat message.
Jev decision: One request contains a five-way Choice for question/hype/conversation/backseat/spam and toxic/spoiler Nouls.
Next action: Code hides toxic/blocked categories first, then blurs likely spoilers; other messages are shown or questions highlighted. One request per message, up to eight in flight, with reusable saved answers when rules change.

Evidence limit: Official example with 29 authored English samples and 0.7 thresholds; results are official reports. No streamer-progress memory, live inputs require integration and messages may remain visible while waiting. Close categories need a local policy; not run or reproduced here.

Original sources: Official cookbook Official replay cache

Semantic code reviewPublic code

Hapsland: turn type-design rules into feedback after edits

Author / team: dearlordylord

Input: A selected type/function declaration, related definitions within configured scope and rule questions.
Jev decision: The Jev backend uses Effect TypeSafe probability judgments for applicable rules, such as meaningless field combinations allowed by a type.
Next action: Code maps configured thresholds to predefined feedback, batching it for supported coding agents and skipping rules with incomplete context.

Evidence limit: Feedback follows edits without guaranteed rollback or repair, and a skipped rule is not a pass. Other models are optional and proof scope is bounded. Root licensing is unconfirmed, so this is a case only. Selected code reaches the provider; not installed or run here.

Original sources: GitHub Source Source Source

Crawler-result triage researchPublic code

Signal triage: Jev probabilities determine retention and scan order

Author / team: h100envy

Input: Signals extracted by code/Grok, crawler focus, source kind and market-data summaries.
Jev decision: One worth Noul per signal judges whether information is concrete, relevant to the focus and worth attention.
Next action: Code drops results below the default 0.15 probability and prioritizes independent scans by Jev probability. Model failure retains the original flow, while deferred items are retried later.

Evidence limit: Probabilities/safety labels do not establish profit or investment safety; this case covers information triage only. Source/market freshness and permissions matter, budgets are process-local and author timing/costs were not reproduced. No crawling, trading or model calls here.

Original sources: GitHub Source Source

Research-orchestration experimentPublic code

Scala MCP experiment: Jev selects evidence operations before another model answers

Author / team: James Ward

Input: A Jackson documentation-research goal, MCP operation schemas and confirmed typed values.
Jev decision: Jev judges bounded next actions with bindable arguments, filters or evidence return, comparing plan-first with stepwise selection.
Next action: The Scala host executes MCP, validates/filters structured evidence and retains checkpoints. The inner loop returns evidence for an outer Bedrock answer, with bounded recovery.

Evidence limit: The app calls the separate zio-typesafe-ai library. README timings are one author network sample across seven arms, not a reliable ranking or savings estimate. Root licensing is unconfirmed, so this is a case only. Model/filter roles vary; no sbt, MCP or model execution here.

Original sources: GitHub Source Source Source

Page-relevance researchPublic code

Relevance scoring: separate intent and terms, record repeat variability

Author / team: matthelam

Input: Page metadata or metadata plus body, an authored search question and ten expected terms.
Jev decision: Two five-level Jev Score request types separately judge intent fulfillment and term centrality; term requests exclude the intent.
Next action: Code normalizes levels into term-sum times intent-fit scores, repeats measurements for means/±2 SD and stale markers, then displays rankings/improvement components and stores results in IndexedDB.

Evidence limit: Noise bands describe repeated-answer variability, not search ranking, factual accuracy or SEO-effect calibration. Source text reaches the model. The author ten-page/100-run study was not reproduced; repeat calls accumulate costs, and no production pages or APIs were evaluated here.

Original sources: GitHub Source Source Source

Response-training prototypePublic code

Scenario-response practice: bounded judgments and local rubrics combine

Author / team: Kim Jibaek / Korea Management Education Institute

Input: A practice scenario, rules, randomized resource constraints and a timed learner response.
Jev decision: A Jev Choice selects accept/defer/decline/unknown, Scores rate two simulated outcomes and Nouls check rubric items and promises.
Next action: Code compares against scenario reference responses and thresholds to compute a pass, recording missing items, timing and practice reports. Coding assistants separately generate scenarios/overall comments.

Evidence limit: Korean prototype with four AI-authored packs; scales are not real customer reactions or employee capability certification. Replies reach OpenRouter, with mobile/Windows/persistence limits. Author cost/timing were not reproduced and no real employees were assessed here.

Original sources: GitHub Source Source

Indirect-injection researchPublic code

Act-level injection check: separate content inducement from task relevance

Author / team: minitru / xChk

Input: Current/recent requests, preceding tool content, a proposed act and up to twelve prior acts.
Jev decision: Multiple Nouls judge divergence from each request and following external content; carries separately judges content-induced actions absent from the request.
Next action: Code requires both carries and intent thresholds to return flagged, also returning probabilities, readability and reasons. The tool itself does not block acts.

Evidence limit: Defaults inspect 400 characters of an act and 6,000 of content, with author-documented padding bypasses. Opaque clicks are unreadable, not safe. The simple attack set lacks holdout and real samples are narrow. Author results were not reproduced and do not replace host permissions.

Original sources: GitHub Source Source

Technical-writing researchPublic code

Style-density check: sentence judgments produce evidence above a baseline

Author / team: jomi-se

Input: Markdown sentences, context and fixed style questions, excluding substantial quotations from author-style counts.
Jev decision: A pinned Jev model makes per-sentence Nouls for maxims, triplets, disclaimers and other traits, with request/answer completeness checks.
Next action: Code computes probability-weighted counts/density, listing source sentences/locations when the 90% Poisson lower bound exceeds the default three-times human baseline. Experimental editing uses a generative model separately.

Evidence limit: A 13-technical-post baseline does not represent all genres/languages, and density does not establish authorship or factual quality. Short texts/quotes have special handling. Node 26/API configuration is required, and author editing/cost claims were not reproduced here.

Original sources: GitHub Source Source Source

Document-extraction/review examplePublic code

Document review: keep extraction confidence and plausibility independent

Author / team: Unsiloed AI

Input: Extracted fields with row IDs/context, while source locations and extraction scores remain separate from Jev input.
Jev decision: One Noul per row checks on-face plausibility without reading the source image, changing values or assessing patient-specific safety.
Next action: Code retains both checks, routing missing/invalid or below-example-threshold values to human review. Row IDs/source locations support inspection, and high Jev answers do not cancel low extraction confidence.

Evidence limit: A commercial author six-row prescription-method demo, not an official TypeSafe case or medical advice. The 0.90/0.50 cutoffs need reviewed-document validation, with policy for near-0.50 answers. Author results were not reproduced; no real medical data or model calls here.

Original sources: Author integration and code Author X

Database text decisionsPublic code

DuckDB: retain typed decisions and distributions inside SQL

Author / team: DataZooDE

Input: Ticket text or structured JSON in SQL rows, user questions and bounded options/ordered levels.
Jev decision: With TypeSafe Jev selected and remote calls explicitly enabled, Nouls/Choices/Scores judge questions expressed in SQL.
Next action: The extension validates responses and returns scalar/distribution columns for SQL filtering, grouping or routing, with duplicate-row reuse and bounded batch concurrency.

Evidence limit: Hosted text leaves the machine and registrations/settings are not persistent. Constant Stub/local Julia/Laya results are not Jev results. Installation channels/signing vary and probabilities/optional calibration need local samples. Not installed or called here.

Original sources: GitHub Source Source

Browser-testing prototypePublic code

Sedum: bounded element selection and flagged probabilistic assertions

Author / team: sedum-dev

Input: Natural-language steps in TypeScript, actionable element candidates and a complete page digest.
Jev decision: By default, a Jev Choice selects a target/none and two Nouls judge claim support and direct contradiction.
Next action: Code rechecks freshness/element roles before Playwright actions. Thresholds/bands yield assertion pass/fail plus low-confidence/contradiction flags, with a separate exit policy.

Evidence limit: Pre-alpha; marginal or contradicted results may pass with flags rather than being unambiguous passes. Optional Clef runs are separate. Author monthly costs are scenario estimates and small timing samples were not reproduced; no external tests or accounts were used here.

Original sources: GitHub Source Source Source Source

iOS Simulator researchPublic code

Simulator image localization: tap after presence and Box gates

Author / team: Saik0s

Input: A synthetic-app screenshot, goal, history and caller-described target catalog, with simulator logical dimensions.
Jev decision: Jev 1.14 Choices select target/operation, a Noul checks visibility and a Box returns normalized edges, with one closer recheck for marginal results.
Next action: Code validates ranges, presence/localization beliefs and freshness, maps the box center to simulator points and acts through AXe before observing again. Model completion and independent persisted-state acceptance stay separate.

Evidence limit: Official vision/Box support is experimental. Three author 1.14 demos and older synthetic evaluations do not establish general app accuracy; models/catalogs also differ. Requires macOS/Xcode/AXe and providers. No simulator actions or model calls here.

Original sources: GitHub Source Source Source

Text-structure conversionPublic code

Flowcharts: Jev selects bounded relations before reviewed code generation

Author / team: Tugrul Guner

Input: Up to eight user-authored steps plus relationship instructions, retaining supplied node labels.
Jev decision: Three Choices per node select role, next node and negative branch, including none.
Next action: A Worker validates options/probabilities and decodes a review-required graph. Code rejects inconsistent branches/invalid edges, then deterministically emits Mermaid for rendering/download after review.

Evidence limit: Not arbitrary code generation or business-flow execution. At most 24 questions, eight nodes and sixteen edges; semantic relations still need review. Author browser successes use fixtures rather than proving deployment/live quality. No documents uploaded or code run here.

Original sources: GitHub Source Source

Experimental vision evaluationPublic code

Image-anomaly research: frame whole units before judging and display

Author / team: 0xRinne / RINNECODER

Input: Image medium, original image and multi-scale regions, retaining whole words/objects or page context.
Jev decision: Jev 1.14 Boxes locate targets/whole units; Choices judge normality, anomaly types or uncertainty, repeating marginal answers and confirming with another format.
Next action: Code treats windows as leads, reframes/crops complete semantic units, merges duplicate boxes and localizes for display with call-cost records.

Evidence limit: The study documents cut-word, cartoon and table-geometry false flags; v7b did not rerun the old 26-image set. Few handpicked images do not establish production accuracy or AI-origin attribution. Images reach an experimental API; author results/costs were not reproduced and no uploads/execution occurred here.

Original sources: GitHub Source Source Source

Official image-cropping examplePublic code

Official Box example: locate a target, convert to pixels and crop

Author / team: TypeSafe AI

Input: A kitchen photo and a coffee-mug target, with image references in assets.
Jev decision: A Jev 1.14 Box returns normalized top/bottom/left/right edges, with an accompanying Noul recommended to check target presence.
Next action: Example code multiplies edges by image dimensions and crops/saves with PIL; low-confidence boxes may be padded/clamped, with edge Nouls checking cut targets.

Evidence limit: Official experimental example requiring the image opt-in header. A Box returns edges even for an absent target, so it does not prove presence. The 0.6 threshold/0.05 padding are teaching defaults; formats/quality may change. No images sent or results reproduced here; not a new cookbook.

Original sources: Official Box and crop code Official Images Official announcement

Deterministic simulation and decision replayPublic code

City simulation: model actions with coded feasibility rechecks

Author / team: William Jones

Input: A simulated citizen’s role, needs, local hazards and a code-filtered finite action set.
Jev decision: One request selects the next action with Choice, rates risk/duty with two Scores and judges routine interruption with a Noul.
Next action: The server validates types/distributions; the simulator accepts by request ID, rechecks current feasibility and runs coded movement/effects, labelling replay, rules, live calls and safety overrides separately.

Evidence limit: Recorded replay is the default and makes no API calls; live failures visibly use rules. The 4,902 valid responses and timings are author records, not validation for real cities/emergencies. Not run here; live calls require separate passcode, credentials and budgets.

Original sources: GitHub Source Source Source Source Author X

Agent trace detectionPublic code

Trace detection: retain problem probability and category separately

Author / team: TraceRoot AI

Input: Parsed trace spans plus user detector criteria, with ordered reductions and omission markers when oversized.
Jev decision: A Noul judges problem presence and a Choice names a template category, other or none in the same request.
Next action: Code applies a 0.5 gate to identified and retains category distribution/confidence. A none label leaves the category unclear, with no written rationale; invalid answers throw and the dispatch layer records an error rather than a normal finding.

Evidence limit: Reviewed modules are Apache-2.0 core; ee directories are commercially licensed, with no claim about enterprise grouping or automatic fixes. Character reductions can omit problems, thresholds need local evaluation and traces reach a provider. No real traces submitted or calls made here.

Original sources: GitHub Source Source Source Source Author X

Experimental vision shadow evaluationPublic code

Vision shadow evaluation: compare bounded answers without replacing tool results

Author / team: Steve Darlow / kerpopule

Input: An existing vision_analyze image and a bounded PASS/FAIL or Yes/No question, with a separately enabled cloud switch.
Jev decision: A TypeSafe Jev Choice checks the image after format/size checks and sensitive-question skips, using the official experimental image header.
Next action: A background queue records class, confidence, agreement and hypothetical hybrid results, rechecking the switch before sending. Errors only log; original tool results stay unchanged.

Evidence limit: Mainline shadow evaluation is separate from the author’s 18/18 branch desktop-action demo. The borrowed 0.6 threshold lacks its own A/B evidence; screenshots cannot be redacted automatically and leave the machine. Official vision is experimental and local Jev-Omni is separate. No images uploaded or code run here.

Original sources: GitHub Source Source Source Source Author X

Long-context research toolsPublic code

Recursive language models: Jev returns probabilities for root-code computation and retrieval

Author / team: Jordan Hochenbaum

Input: Individual text items, finite labels, questions and windowed documents, with explicit shared context/item association.
Jev decision: Choice classification and Noul judgments; locate first ranks windows, then lines/sentences, returning original offsets and combined scores.
Next action: Tools batch bounded concurrent calls, reject missing answers and return probabilities/original passages to DSPy or custom RLMs for root-code counting, filtering and answering, with separate Jev accounting.

Evidence limit: Research library with small single-run author results. Jev neither generates nor authorizes the root program. Token-estimate/fixed-rate budgets can err and exclude root-model costs; source text reaches providers. No models or sandbox programs run here.

Original sources: GitHub Source Source Source Source Source

Source-match rerankingPublic code

Grep reranking: judge snippets and return original locations

Author / team: AI Ready Future

Input: Grep-matched windows, file paths/line numbers and a natural-language question, with at most 300 characters per submitted line.
Jev decision: Direct Jev Nouls judge whether numbered snippets answer the question, at most 32 per request with bounded concurrency.
Next action: Code validates probabilities/answer counts and sorts by score, path and line before returning original text/locations. Errors stop without partial ranked output.

Evidence limit: Reranks only pattern matches, not full-corpus semantic recall. Pinned mainline implements it while release README text still limits the release to key setup; published packages/gateways are unverified. Snippets leave the machine and the 0.4 cutoff needs evaluation. Not installed or called here.

Original sources: GitHub Source Source Source Source

Feedback-memory simulation researchPublic code

Synthetic-lead evaluation: bounded actions with feedback-memory comparisons

Author / team: SenseLab / raia-live

Input: Generated lead text/fields, written policy and strategy-supplied memory, including scripted policy shifts and noisy reviews.
Jev decision: A fixed Jev model chooses among AE routing, nurturing, self-service, partner or disqualification, optionally selecting a memory basis.
Next action: Code simulates outcomes/reviews, updates retrieval or SenseLab memory/traces, runs configured repair-evaluation loops and generates comparison reports, without acting on a real CRM.

Evidence limit: Synthetic losses/accuracy are neither real revenue nor site measurements; memory updates do not train Jev weights. API failures choose the first action with an error record, not business fail-closed handling. External SenseLab/eval access is separate. No calls made here.

Original sources: GitHub Source Source Source Source

Desktop-interaction research prototypePublic code

Next-action suggestions: Jev selects bounded candidates for Tab-key acceptance

Author / team: Alara Martin and collaborators

Input: Active controls, recent actions and values already visible on other pages, with candidate actions built in code.
Jev decision: A Choice selects the next control or none, with separate finite Choices for field/select values. The Claude text-generation path is separate.
Next action: Code displays an acceptable ghost suggestion for Tab-key execution. Slow/failed calls may replay matching-screen caches, while learned repetitions use separate zero-model rules.

Evidence limit: Hackathon prototype and public-code case only; root project license unconfirmed. Code boosts some button confidence to at least 0.7, not raw model probability, and cross-page text reaches the provider. Payment demos are testnet-only and do not establish payment safety. No execution, transactions or reproduced effects here.

Original sources: GitHub Source Source Source Author X

Browser resource-policy prototypePublic code

Browser blocking: policy decisions become scoped rules

Author / team: Honeybank Studios

Input: Uncovered hostnames, page site, resource/party metadata and user policy, without full URLs or cookies.
Jev decision: Two Choices per item select block/allow and a host category, batching at most eight items.
Next action: Code thresholds/caches block decisions and compiles scoped dynamic rules. User overrides/pauses take priority, errors fail open and cross-site reuse can be disabled.

Evidence limit: MV3 first requests can pass before decisions; no path-level or cosmetic filtering. Missing probabilities fall back to choice/confidence or defaults and may overblock. Spend limits are soft, seed lists separately licensed and site/host metadata leaves the browser. Extension not installed or tested here.

Original sources: GitHub Source Source Source

Semantic lint and reviewPublic code

Semantic code checks: judge rule deviation and locate original excerpts

Author / team: darkmatter

Input: Source code, Markdown rules/good-bad examples and configured additional context.
Jev decision: Nouls judge deviation and inclusion/exclusion scope; Choices select sections/start-end lines and a Noul evaluates context sufficiency.
Next action: Code filters by rule thresholds/scope, validates locations and reports original excerpts, probability and context hints with caching. Missing answers are not cached as clean results and source code is not automatically fixed.

Evidence limit: Probabilities/locations may be wrong and do not replace deterministic lint, compilers or security guarantees. Source/additional reads reach providers; moving aliases/caches need maintenance. Default Jev and other providers are separate. Author evaluations not reproduced; not run here.

Original sources: GitHub Source Source Source Source

Text metrics and sample-relative reviewPublic code

Prose metrics: bounded judgments combined with local computation

Author / team: Chad Boyda

Input: English text, passages and words with supplied word-class/genre options and ordered rating levels.
Jev decision: Jev Choice/Score/Noul questions supply judgments beyond local routes, with whole-text/chunk distributions and genre probabilities for combination models.
Next action: Local arithmetic/fitted weights produce metrics; profile/compare flag deviations from author samples for rereading. Unavailable Jev triggers a warned local recomputation; cadence is separate and makes no model calls.

Evidence limit: Not a universal writing-quality judge; English resources/fitting samples limit scope and data components have separate licenses. Author validation not reproduced. Text reaches providers and old jev-latest caches can age. No articles submitted or models run here.

Original sources: GitHub Source Source Source Author X

GSPro visual commentaryPublic code

Simulator golf: turn image judgments into thresholded commentary facts

Author / team: jjmerri

Input: A simulator minimap crop and distance to pin after explicit Jev selection, with color/geometry candidates found in code.
Jev decision: Boxes locate ball/pin, Nouls confirm water/sand/trees and Choices read finite digits/directions, using the experimental image header.
Next action: Code checks position/confidence, derives geometry/distances and filters facts/hazards for the commentary model and prewritten branches. Timeout/failure falls back to another vision model and separate TTS generates speech.

Evidence limit: Specific to Windows/GSPro screenshots, not real-course safety navigation. Boxes/images are experimental and example thresholds/timing/costs are author reports, not reproduced. Crops leave the machine; other LLM/TTS results are separate. No screenshots collected or code run here.

Original sources: GitHub Source Source Source

Coding rules and file organizationPublic code

Pi: check content rules and new-file placement before writing

Author / team: kurowashi

Input: A proposed Pi edit/write, matching project rules and context; placement checks also receive a bounded project tree and proposed content.
Jev decision: Each rule becomes a Noul question; its probability is inverted for negated checks and compared with that check's minProbability.
Next action: Any failed check returns block:true and corrective feedback to stop that tool call; passing checks let Pi continue writing.

Evidence limit: Source review only, without installation or API calls. Only edit/write are covered; bash changes are outside scope. onError defaults to allow and unmatched or untrusted configurations may be skipped. Character/tree bounds do not ensure full context or provide a security boundary.

Original sources: GitHub packages/core/src/jev.ts packages/content-guard/src/index.ts packages/placement-guard/src/index.ts packages/core/src/config.ts

Coding-agent reasoning configurationPublic code

OpenCode: choose and switch among allowed reasoning levels

Author / team: atvari-eu

Input: The user prompt, a processed recent-context digest, and the reasoning levels supported by the current model; a TypeSafe System One endpoint and valid Jev model can be configured explicitly.
Jev decision: The effort-only path offers the allowed levels as Choice options, rejects out-of-set answers, and retains the current level when a numeric confidence is below the configured threshold.
Next action: A valid pick becomes switchTo; the host calls session.switchModel with the variant and records the switch provenance. Code handles manual selections and failure fallback.

Evidence limit: Neither OpenCode nor a paid model was run. The default OpenCode Console endpoint/jev-1.13-free has extra client-version and credential requirements; its free route was not independently verified. Missing confidence does not trigger the numeric low-confidence branch. No measured savings or acceptance of every other feature is claimed.

Original sources: Choice and resolution Transport and host switch README

Risk-assisted review of coding toolsPublic code

Shell gate: connect a Noul risk judgment to Pi pre-execution hooks

Author / team: psygreg

Input: A pending Pi shell command, with the agent-reflex classifier explicitly configured for the TypeSafe endpoint and a Jev model.
Jev decision: A Noul asks whether the command may damage system files, remove directories without backup, or leak environment keys; code reads answers.q.noul and applies its threshold.
Next action: For a recognized shell tool, the tool_call hook returns block:true when the judgment exceeds the threshold; otherwise the host continues its normal handling.

Evidence limit: Only the Pi/TypeSafe source path was inspected; no installation, command execution, or model-safety test was performed. The classifier fails open when unavailable or unconfigured and cannot replace permissions or sandboxing. Other provider presets and all eight host integrations were not independently accepted.

Original sources: TypeSafe classifier Pi hook and threshold README

Personal feed rankingAuthor post only

Personal RSS: rank with interest scores and time decay

Author / team: 潦草学者 Scholar.L / @liaocaoxuezhe

Input: An interest profile derived from reading and saved-item behavior, plus subscribed RSS content; a separate model extracts the interests.
Jev decision: The author reports using Jev to score how content matches personal interests; the primitive, score range, and prompts are not disclosed.
Next action: The local program combines the scores with time decay to reorder daily and seven-day RSS timelines; the original thread shows a comparison with chronological ordering.

Evidence limit: Author post and demonstration only, not a site-run test. The local modifications, decay formula, and deployment are not public. Upstream PaperRss is the starting point, not evidence that upstream integrates Jev, and is not added as a Jev project.

Original sources: Author implementation note Author demonstration

Offline image-classification evaluationCode + author post

MNIST: ten-way image classification and error analysis

Author / team: kaitoy / @kaitoy3_

Input: MNIST 28×28 grayscale digit images, upscaled by default to 280×280 PNG, supplied as an SDK Image with the experimental-image opt-in header.
Jev decision: One Choice selects a digit from the strings 0–9; code reads the choice, confidence, actual response model, and token count.
Next action: Predictions are compared with labels, API errors are retained separately, and code produces all-sample/answered accuracy, a confusion matrix, and per-image CSV data for a local error gallery.

Evidence limit: Code and original-post review only, without downloading data or calling the model. The 10,000-image, 92.45% result is author-reported, not independently reproduced. Images are an experimental preview and the jev-preview alias may change. No root license or pyproject license declaration was found, so this is a public-code case rather than a license-verified project listing.

Original sources: Image Choice Evaluation and CSV Author results Author X post

Model routingPublic code

OpenRouter proxy: three-lane routing with tool continuation

Author / team: adymitruk

Input: Bounded excerpts of the latest user objective and current turn, plus whether tools are present.
Jev decision: A Jev Choice through OpenRouter alpha/decisions selects cheap, fast_mid, or smart_pro; cheap choices below 0.72 confidence move to the middle lane.
Next action: Rewrite the model and provider ordering before forwarding chat/completions, for streaming or ordinary responses; tool continuations reuse a short-lived route and classifier failures fall back to the middle lane.

Evidence limit: Pinned source review only, without running the proxy or model. Continuation keys use the first user message and are not verified session isolation. No root license was found, so no license-verified project listing is added.

Original sources: Choice and downstream forwarding

Meeting-update routingPublic code

Meeting mindmap: route updates by new decisions and action items

Author / team: daiki-beppu

Input: New transcript remarks and up to six recent remarks for context.
Jev decision: A Jev Noul asks whether new remarks contain decisions, agreements, or action items, using the yes probability rather than the chosen class confidence.
Next action: Send probabilities below 0.3 to Haiku, otherwise or on judge failure to Sonnet; retain separate updater response state and pending screen changes.

Evidence limit: Jev routes; downstream models generate mindmap diffs. The judge can be disabled or replaced, and local mode defaults to no cloud judge. No meetings were recorded or read and no costs were measured.

Original sources: Noul and updater consumption System One request Judge configuration

Memory retrieval and injectionPublic code

jev-mem: gate retrieved memories before context injection

Author / team: must-lioncho

Input: A prompt excerpt and titles, summaries, and dates of five records retrieved by default from local claude-mem.
Jev decision: One TypeSafe System One request asks a Noul per candidate about whether that record materially helps the current task.
Next action: Rank by probability and by default inject only the best record reaching 0.7; an optional bounded multi-record mode is available, with no injection on no match, timeout, or failure.

Evidence limit: Relevance does not establish truth or freshness. Prompt and memory summaries are sent to external Jev. Source review only: no local memories read, hooks installed, or user data transmitted; the three-prompt demonstration is not an independent benchmark.

Original sources: Noul and threshold selection Retrieval and injection Native API client

Document risk signalsPublic code

liedar: screen document metadata and page images

Author / team: colesmcintosh

Input: Metadata and page images from PDF, PNG, or JPEG files, with at most the first ten PDF pages.
Jev decision: A native Jev request asks Nouls for overall suspicion and seven fixed signals including conflicting dates, visual edits, and inconsistent numbers.
Next action: Use a 0.5 threshold for likelyFraud and reported reasons, sorting signals by probability for terminal or JSON consumers.

Evidence limit: A screening signal cannot establish fraud. Images are experimental and probabilities are not calibrated for fraud. Source review only, without uploading documents, making paid API calls, or reproducing the author's cost table.

Original sources: Fixed questions and report Multipart Jev client Limits and warning

Listing-photo review demonstrationPublic code

Listing photos: rule probabilities and three-way review

Author / team: Mani Khanuja / mani-aiml

Input: A listing description, resized full photo, and four corner tiles; code checks deterministic dimensions and squareness.
Jev decision: Jev Nouls check white background, overlays, a single item, sharpness, and full framing; supported models also locate the item with a Box.
Next action: Convert applicable rules to compliance probabilities: minimum ≥0.9 means publish, ≤0.2 means send back, otherwise ask a person; the Walmart demonstration also checks box area for frame fill.

Evidence limit: A community offline rule demonstration that outputs verdicts and scores without publishing listings or guaranteeing current marketplace compliance. Images and Box are preview features; no photos were downloaded and no model or independent evaluation was run.

Original sources: SDK Noul and Box Thresholds and verdicts Verdict consumption

Author coding-router experimentAuthor post only

Coding routing: three open-model tiers and a selected-subset experiment

Author / team: Shivay Lamba / @HowDevelop

Input: The first user objective of a coding task, with tool turns retaining the selected tier.
Jev decision: The author describes Jev classifying routine, moderate, or hard tasks into fast, balanced, or strong tiers; primitives and full routing prompts were not verified this run.
Next action: Route coding-agent requests through nconnect to the chosen model, escalating after three tool failures or an explicit strong-tier request.

Evidence limit: Author article only, not a site-run test. The reported 78.5% saving is from a post-selected 32 of 50 tasks that passed and cost less, not whole-set success or a universal saving. The experiment repository and nconnect have since been source-reviewed and listed separately; the experiment and its effects remain independently untested.

Original sources: Author experiment and selection method

Natural-language directory searchAuthor post only

offline.directory: match offline apps to a visitor's situation

Author / team: Denis / @dnsk96

Input: A visitor's natural-language situation and candidate application entries from the directory.
Jev decision: The author reports Jev scoring each app's suitability for the situation; full prompts and the exact primitive are not public.
Next action: Show the best eight results with fit labels and uncertainty for low confidence; keyword results appear first, with keyword fallback and logging on Jev failure.

Evidence limit: Author-post case without independently testing search, latency, or deployment. Result explanations are not established as Jev-generated prose, and a Grok-built site is not Jev site generation. Source code was not verified, so no open-source project is added.

Original sources: Author case study

SQL text-analysis integrationAuthor post only

MotherDuck: classify customer complaints in SQL

Author / team: MotherDuck / Hamilton Ulmer, Till Döhmen, Jacob Matson

Input: Conversation text from a customer_conversations table and four predefined complaint categories: billing, technical, sales, and account.
Jev decision: A Choice in prompt_jev() selects the main complaint from the supplied categories, with instructions and category meanings passed as SQL function arguments.
Next action: SELECT returns conversation_id and classification per row as structured columns for subsequent table analysis; this example does not establish automatic support-call transfers.

Evidence limit: Author post and vendor SQL example only, without running queries or transmitting conversations. Reported speed, cost, and accuracy concern the vendor’s AG News classification benchmark, not support-complaint accuracy or independent reproduction. This hosted integration has no verified open-source implementation here, so no GitHub project is added.

Original sources: MotherDuck original post Vendor SQL example TypeSafe recommendation

Offline enterprise-search evaluationAuthor post only

Glean: evaluate reranking formulations and tie effects

Author / team: Tony Gentilcore and Glean coauthors

Input: Captured enterprise search queries and up to 50 candidate results per query, compared on the same internal evaluation set.
Jev decision: The authors compare pointwise Nouls, shared-state Nouls, Scores, and probabilities from a single Choice as relevance signals; Choice is strongest in their experiment.
Next action: Reorder candidates by the relevance signal and evaluate Recall@6, then remove production-order tie breaking to test whether gains come from Jev itself.

Evidence limit: Author-reported offline evaluation only, without public implementation or independent reproduction. Many candidates tie, and retaining production order improves results; access limitations also make absolute metrics unrepresentative of production. The authors explicitly do not establish a replacement for Glean’s production ranker.

Original sources: Author article: reranking experiment TypeSafe recommendation

Offline citation-quality evaluationAuthor post only

Glean: repeatability of citation-coverage and support judgments

Author / team: Tony Gentilcore and Glean coauthors

Input: One fixed 1,448-word response and its citation evidence, with coverage judgments repeated three times on the same 28 paragraphs.
Jev decision: Make bounded policy judgments about whether evidence-requiring claims have citations and whether cited sources support the attributed claims; full API primitives and prompts are not disclosed.
Next action: Aggregate coverage/support judgments and compare paragraph changes and pairwise disagreement across three identical-input runs against another model, without automatically editing answers or establishing factual truth.

Evidence limit: Author-reported repeatability study on one response, without code or independent reproduction. No independent human gold labels are provided, and support criteria and denominators differ between models: stability is not accuracy. Timing definitions also differ, so this is not end-to-end speedup or production-deployment evidence.

Original sources: Author article: citation judging TypeSafe recommendation

Human editorial assistanceAuthor post only

Creator Playground: select hooks and review before publishing

Author / team: Defileo / @defileo

Input: Several opening lines written by the author and the full draft intended for publication, supplied individually or per line in Playground.
Jev decision: A Score evaluates hooks against concrete reader situations and a Noul flags formulaic marketing language; a separate pass evaluates draft regret risk and whether specific claims need sources.
Next action: The author examines scores and confidence to select an opening, add sources, revise claims, or rethink the idea; a person decides publication.

Evidence limit: Author article describing personal use and sample questions only; Playground, engagement improvements, usage, and cost were not independently checked. No automatic writing or posting is established. Subjective style judgments do not establish AI authorship or factual verification.

Original sources: Author workflow and questions

DM triage and human reviewAuthor post only

Creator DMs: classification, priority, and human review

Author / team: Defileo / @defileo

Input: Individual new direct messages and predefined categories for paid work, free help, fans, pitches, spam, and other messages.
Jev decision: A Choice classifies the sender’s request and a Noul asks whether a week’s delay could lose an opportunity; other and low-confidence human review remain available.
Next action: The author reports a Zap processing new messages, writing paid-work leads and confidence to a Notion board, batching other messages, and periodically reviewing REVIEW rows and revising categories.

Evidence limit: Author description only, without automation export, source code, or independent end-to-end acceptance. Script-building and Zapier/Make instructions are not verified deployment evidence. Users must authorize model transmission of DMs; no private messages were read, accounts connected, or messages sent in this review.

Original sources: Author DM routine and review boundary

Document-type recognitionPublic code

Document types: fixed vocabulary and candidate probabilities

Author / team: Landon Thornton / LandoCole

Input: Document text or an excerpt, an excerpt-strategy note, and fixed definitions for 21 document types plus other.
Jev decision: Send one document_type Choice to native /v1/systemone; code checks the selected option, confidence, candidate probabilities, and token fields.
Next action: The API returns the category, ranked probabilities, actual model, and latency to the page; the animation visualizes probabilities and lands on the choice rather than revealing inference.

Evidence limit: Pinned source review only, without uploading documents or calling the model. Results on 43 synthetic documents are an author demonstration, not real financial-document accuracy. Excerpts still go to hosted inference; production auto-filing or human escalation wiring was not verified.

Original sources: Native Choice and response parsing HTTP consumer Probability visualization Synthetic evaluation boundary

Analytics evidence and workflow handoffsPublic code

SignalWeave: BI evidence to bounded policy results and handoffs

Author / team: waddle-zoo

Input: A user-reviewed analytics card, normalized observations, source evidence, and code-computed numeric comparisons, with calculations separated from semantic policy.
Jev decision: With Jev configured, Choices judge watch items and bounded outcomes such as ignore, investigate, and notify, while Nouls answer card questions; low-support action outcomes fall back to investigation.
Next action: The engine applies source-error and policy gates, returning evidence, investigation plans, destinations, and receipts for the calling agent to analyze further and handle delivery.

Evidence limit: Source review only, without connecting BI systems, scheduling checks, or sending notifications. Jev does not supply causal explanations and numeric contributions are not causal proof. Other backends are supported, so not every run is a Jev run. Evidence or budget gaps can defer investigation; author acceptance is distinct from independent testing.

Original sources: SDK questions and outcome parsing Gates and workflow handoff Service and caller responsibilities

Coding-agent recovery experimentPublic code

RecoverIQ: recovery advice with deterministic budget constraints

Author / team: sanghamitrajohri

Input: Failure summaries, attempt history, current model, damaged-file information, checkpoint availability, and remaining budget, with only currently feasible actions offered.
Jev decision: A Jev Choice ranks retry, model switch, checkpoint restore, human escalation, or terminate; separate questions classify failure and whether retry helps, with a default 0.3 Noul retry gate.
Next action: A deterministic policy rejects invalid, unavailable, or unaffordable advice before graph nodes retry, switch tiers, restore, or interrupt for a human; Jev unavailability uses an explicitly labeled rules fallback.

Evidence limit: Mock and live modes are distinct; no generated code or paid experiment was run here. The author’s 108-run study is small, its retry gate was adjusted after the first live call, and human-cost assumptions change comparisons. No root license was confirmed, so this is a code case only. Budget gates depend on cost estimates and do not guarantee a hard billing limit.

Original sources: Native SDK decisions Retry gate and fallback Deterministic budget policy Action consumption

Draft-editing assistancePublic code

Jev Send Guard: draft-tone advice in allowed applications

Author / team: MrDesjardins

Input: A draft in the focused text field of a user-allowlisted application, checked after typing pauses; readable prior messages are included when context is enabled, and no apps are watched by default.
Jev decision: Configurable Jev Nouls assess tone, a clear ask, politeness, sarcasm, and related concerns, flagging an item at probability 0.7.
Next action: Code displays severity-based advice beside the field with separate model results and latency; it does not intercept sending, block it automatically, or send messages.

Evidence limit: Source review only, without installation, accessibility authorization, or reading user drafts. Windows acceptance is author-reported and macOS remains untested by the author; drafts and optional prior messages leave the device. Missing answers become zero in the inspected code, so advice does not establish absence of risk. No root license was found, so no project listing is added.

Original sources: Noul requests and threshold Advisory popup consumption Application allowlist Platform and permission boundaries

Offline agent-decision evaluationAuthor post only

OpenClaw: offline bounded decisions and low-confidence cases

Author / team: Michael Gannotti / Vai

Input: Short scenarios for skill selection, speaking, acting/asking/refusing, task shape, and evidence retention, with predefined answers.
Jev decision: The author uses Jev Choices, Scores, and Nouls for closed questions, comparing labels and confidence and highlighting uncertain results around 0.50.
Next action: The author summarizes offline results and low-confidence rows and proposes returning advice below 0.80 to the main agent or a person; production tool-execution wiring is not established.

Evidence limit: Author article only, without row-level verification or reproducing the reported 32/32, latency, or cost. One injection and a few language/reasoning probes do not establish safety or multilingual ability; a confidence threshold is not permission. Jev does not generate the final reply.

Original sources: Author pilot and limitations

Offline visual-classification evaluationCode + author post

Product categories: paired text-only and main-photo evaluation

Author / team: Gbolagade Ishola / @gbolagadehq

Input: Text and main photos for the same 1,999 products, with fixed category ordering; the author reports padding or resizing out-of-limit images without cropping.
Jev decision: Jev 1.14.0 Choice selects a fixed category and returns probabilities; the adapter’s assets image references/explicit experimental header and actual runner were reviewed.
Next action: Compare paired predictions with labels, measuring image gains, confidence distributions, and input overhead, and distinguish near-duplicate-category acceptance from raw-label scoring.

Evidence limit: Author-run offline evaluation, not independently replicated; near-duplicate acceptance rules, public data and labels have limits and the image gain is small and borderline. Confidence-based escalation is only proposed. No root license was found, so no open-source-project listing or extension to damage, customer photos, Box or multilingual use.

Original sources: Author paired study and deviations dbench/adapters.py dbench/run.py README.md

Knowledge managementPublic code

Obsidian tag scoring before reviewed writes

Author / team: holy-max

Input: User-selected note titles/body scope and existing vault tags, with exclusions and optional skipping of already tagged pairs.
Jev decision: Native Jev Noul judges each note/tag pair in batches; adjustable thresholds and a human-review band reclassify scores without inventing tags.
Next action: The UI first shows a matrix and proposals; code writes YAML/inline tags only after acceptance, with manual additions, withdrawal and reset for this run.

Evidence limit: Independent MIT community implementation inspired by Kaku’s public UX, not an official Kaku plugin. Source review only; no installation or notes sent. Selected text leaves the device. Missing answers filled with zero are not proven negatives; thresholds and rough cost estimates are uncalibrated.

Original sources: src/llm/systemone.ts src/judge/scheduler.ts src/judge/bucket.ts src/ui/auto-tag-view.ts src/vault/tags.ts README.md

App searchPublic code

Semantic app candidates in an Android launcher

Author / team: polidog

Input: A search phrase and a bounded list of installed launchable apps with names and package identifiers.
Jev decision: When strong lexical matches are absent, Jev Choice assigns probabilities to apps and Noul checks whether a suitable app exists.
Next action: Code retains up to five options with probability ≥0.05 when exists ≥0.3, merges them with local matches, and launches only after the user clicks or presses Enter.

Evidence limit: MIT Android community code; device tests are author-reported. We did not install it, grant permissions or verify a Play listing. Thresholds are explicitly heuristic, API failures fall back to local results, and app lists/search text leave the device; suggestions are not automatic execution.

Original sources: app/src/main/java/jp/polidog/dotlauncher/JevSearch.kt app/src/main/java/jp/polidog/dotlauncher/LauncherActivity.kt README.md

Tool-call reviewPublic code

Tool-call verdicts and confirmation in Command Code

Author / team: felinae98

Input: Tool name, bounded arguments, working directory, recent user requests, assistant intent and flagged untrusted content.
Jev decision: Jev Score/Noul assesses risk, approval needs, user intent and untrusted-instruction following; deterministic thresholds combine answers into deny/ask/allow.
Next action: The mod blocks deny in beforeToolCall, prompts for ask in an interactive UI, and auto-approves only allow in onPermissionRequest; selected tool results/instruction files are also scanned.

Evidence limit: MIT community integration reusing jev-guard policy, not a safety guarantee. Service failure defaults to fail-open; headless ask only warns and proceeds. Read-only tools can be skipped and custom backends may not be Jev. No installation, user-permission changes or adversarial retest; users must review external transmission of context.

Original sources: src/jev.js src/policy.js src/mod.ts README.md

Agent output reviewPublic code

Dimension-wise selection of existing Harness² outputs

Author / team: SASUKE40

Input: Anonymized finished candidates, task requirements, sanitized source materials and work context, excluding benchmark verdicts.
Jev decision: An optional native Jev backend scores delivery, conformance, source fidelity, consistency and usability from 0–2; code validates probabilities/confidence and ranks dimensions lexicographically.
Next action: It selects one existing candidate and persists an audit; missing answers, low confidence, ties or audit-write failure defer to the existing agent selector.

Evidence limit: Community-fork wiring under Apache-2.0, not an official TypeSafe or Google Jev integration. Calls and consumer were reviewed without benchmarks or paid requests. Jev does not generate/rewrite deliverables; parent-framework metrics do not prove this backend’s performance.

Original sources: harness2/core/jev.py harness2/core/selection.py README.md

Visual classification experimentCode + author post

Aircraft classification with external harness refinement

Author / team: Edward / SASUKE40

Input: Aircraft photos, a finite aircraft-type taxonomy and prompt rules/tool settings supplied by the harness.
Jev decision: Jev 1.14 uses Choice or per-type Noul for aircraft type and Box for localization; code parses labels, probabilities, boxes and uncertainty warnings.
Next action: Code writes labels/detections for candidate comparison; the surrounding harness proposes, probes and composes rules/tools and retains experience without updating model weights.

Evidence limit: The author reports 49% to 63% over three rounds; we did not rerun or inspect every run. This does not establish generalization or that Jev generates tools. Synthetic demos, real photos and API execution differ; image/Box features are experimental, and FGVC-Aircraft photos have separate non-commercial research terms.

Original sources: X harness2/vision.py harness2/image_demo.py harness2/aircraft.py

Safety evaluationAuthor post only

Jev self-gating before tool execution in DTap

Author / team: Zhaorun Chen

Input: A complete tool call selected by Jev with filled arguments, plus preceding trajectory context.
Jev decision: The authors ask Jev again to judge the call before execution rather than trusting its initial tool choice.
Next action: The evaluation inserts a pre-execution gate and compares direct misuse, indirect prompt injection and benign task completion.

Evidence limit: The September 27 author thread and September 29 official quote were verified. Authors report lower attack success but benign success also falls from 60.9% to 55.8%, with substantial residual risk. Public implementation, exact output type/threshold, full samples and independent replication were not verified; this is neither safety certification nor evidence about newer Jev versions.

Original sources: X 作者门控细节 TypeSafe X

Human decision supportCode + author post

Jev probabilities alongside Claude’s options

Author / team: PeesukaGu

Input: The current question, finite options and up to 3,000 conversation characters ending at the last user prompt, with current recommendation marks and machine messages filtered.
Jev decision: The plugin uses the jev CLI’s Choice to return option probabilities and marks a pick using a confidence threshold, defaulting to 0.6.
Next action: By default it annotates visible descriptions while the user chooses. Explicit auto_select fills answers only when every question is single-select with a confident pick, and tells Claude that Jev chose.

Evidence limit: MIT community plugin; not installed, no user transcripts read or paid calls made. Matching rates on 221 past answers are author-reported, and higher thresholds did not establish better preference matching. Auto-select may differ from the user. Excerpts leave the device; display separation does not prove reliable preference prediction.

Original sources: scripts/jev-advise.mjs hooks/hooks.json README.md X

Literature retrievalPublic code

Jev screening and classification over local paper sets

Author / team: Zilize

Input: Paper metadata recalled from a local arXiv corpus by keyword/date/category and set operations, with inclusion criteria and 2–12 user-defined classes.
Jev decision: Native Jev Noul screens each paper; single-label classification uses Choice with other, and multi-label classification uses per-class Noul, retaining probabilities and uncertainty bands.
Next action: Code writes include/exclude/classification outcomes using node thresholds, committing answered batches and progress together in SQLite. An immutable set graph exposes decisions and resumed jobs process undecided items.

Evidence limit: Apache-2.0 community plugin, not installed and no corpus imported. Defaults such as 0.5 inclusion and 0.8 single-label confidence are application policies, not accuracy guarantees. Timing demonstrations/estimates are author-reported. Local storage does not mean local inference: selected evidence goes to hosted Jev, and recall is bounded by the ingested corpus.

Original sources: src/sets/jev.ts src/sets/jobs.ts src/jev-defaults.ts README.md

Sports commentary supportPublic code

Bounded coach-card selection during basketball stoppages

Author / team: aiden-guan

Input: Up to eight short code-generated insight cards with game situation and stoppage context; cloud payloads use player tokens and exclude local metadata.
Jev decision: Jev Noul judges whether cards are currently actionable and Choice selects among the bounded cards and none; decoding thresholds reject uncertain or unsupported answers.
Next action: The consumer ranks and displays accepted results on the coach board; a confident none can suppress a card. Off, late, failed or low-confidence model results fall back to deterministic priorities without blocking the event loop.

Evidence limit: MIT community code. Native SDK wiring, live/offline-mode separation and the consumer were reviewed without cameras, game execution or model calls. Simulated/replay tests and author test counts do not establish real-game recognition or advice accuracy. README and implementation timing budgets differ, so no latency claim is repeated.

Original sources: courtvision/decision/client.py courtvision/decision/questions.py courtvision/decision/advisor.py courtvision/narration/narrator.py courtvision/pipeline.py README.md

Service feedback reviewAuthor post only

Nine-question FFT feedback analysis and human review queues

Author / team: Jan du Plessis / AI MedReview

Input: FFT free_text and do_better fields from a Google Sheet, combined, filtered for empty/short text, anonymized and assigned a stable review identifier.
Jev decision: The author uses nine independent Jev questions per review: Choice for sentiment/topic/staff group, Score for strength/actionability/urgency, and Noul for safety, dignity/inclusion and leaving risk.
Next action: An async batch job persists answers/probabilities to CSV with checkpoints. Streamlit reads stored results and uses code rules for alerts and low-confidence alternative topics for staff review, without inference on page views.

Evidence limit: The author’s public article and displayed code were reviewed, not the original repository/license or any patient records. No NHS endorsement or clinical diagnosis is implied. Thresholds, anonymization and deployed effects were not independently validated; integer score storage loses information and the jev-latest alias can change.

Original sources: 作者文章 X

Support shadow evaluationAuthor post only

Shadow classification and disagreement review on WhatsApp

Author / team: Mauricio Suarez Vega

Input: A parallel copy of text history and booking context, excluding some operational information and image pixels available to the main support pipeline.
Jev decision: Jev 1.13.0 classifies finite intents such as quotation, complaint and payment, plus binary questions about job seeking, human review and explicit proposal confirmation, with rubric versions separated.
Next action: It logs labels, probabilities, latency and errors for stratified comparison and later independent labeling; it does not change customer replies, create bookings or automatically take over service.

Evidence limit: The article is dated October 2 and was reshared October 22. The author’s 703 turns include repeat contacts, and agreement is not human-labeled accuracy. 128/131 is response availability in a provider-failure subset, not correctness. Shared infrastructure and different cost/timing scopes preclude claims of business gains or independent redundancy. No customer conversations were read or experiment rerun.

Original sources: 作者复盘 X

Game research reportAuthor post only

Bounded game actions and post-game playbook refinement

Author / team: Agnes AI / Aiden

Input: The hero’s visible state, current plan and currently available decisions; the coach receives complete post-game records, while playing models do not.
Jev decision: Jev returns probabilities over bounded decisions and chooses an action, while larger Agnes models plan and revise the playbook after games.
Next action: Playbook code executes actions at a higher frequency; coach-proposed prompt, action-space and reflex-code changes pass fixed promotion tests, without model-weight training.

Evidence limit: Author report dated October 12 only, with no runnable core or verified root license, so no open-source-project entry. Win rates/latency are author-reported against built-in bots; a 95% check score is not a pure win rate, future 3v3 dashed points are targets and some transfer was manual. No extension to human competition or robotics is established.

Original sources: REPORT.md README.md

Workflow integration previewAuthor post only

Bounded judgments and threshold review with the UiPath preview connector

Author / team: UiPath / Sandeep Panda

Input: JSON state supplied by a UiPath workflow with predefined options or ordered criteria; the vendor illustrates decision activities such as email routing.
Jev decision: The connector calls Jev Choice, Score and Noul with the user’s own TypeSafe key, returning typed answers, probabilities and confidence where applicable.
Next action: Workflow code consumes answers and task-specific thresholds, continuing suitable results and handing uncertain ones to humans or reasoning agents; the model itself does not authorize business actions.

Evidence limit: UiPath’s primary article and TypeSafe’s recommendation were verified. This is a preview/vendor example, not a tenant execution or verified customer production loop. The 94% figure measures LLM-judge agreement; cost/latency come from early internal experiments, not our tests. Requests use the user’s TypeSafe agreement and bypass UiPath AI Trust Layer.

Original sources: UiPath一手说明 UiPath X TypeSafe X

Grievance triage prototypePublic code

Grievance triage prototype with 23 judgments and versioned policy

Author / team: aen07

Input: A development-project grievance, receipt date and channel; only public source code was inspected.
Jev decision: One native System One call uses Noul for project, issue and safety signals and Score for urgency; Python computes date windows.
Next action: Versioned thresholds and P1–P8 rules produce department, urgency, redaction and review fields. Safety risks, uncertainty or API failures go to human review; clear routine items may be auto-routed.

Evidence limit: Apache-2.0 community prototype, not an accepted real grievance-handling system. No complaint caches read, model calls run or safety recall/redaction verified. Sample evaluation is author-reported and does not authorize decisions about personal rights.

Original sources: GitHub Source Source Source

UI testingPublic code

Flutter semantic testing from bounded actions to independent assertions

Author / team: lucasgm1997

Input: Semantic nodes from a debug Flutter app, a goal, unmet assertions and input-field descriptions; actual input values stay local.
Jev decision: A native Jev Choice selects the next step from executor-built tap, fill, wait and blocked candidates, returning confidence.
Next action: The executor validates candidate and confidence, reobserves before acting, calls Marionette and independently checks assertions. UI drift, low confidence, no semantic change or step exhaustion stop the run.

Evidence limit: No app installed, emulator started or model called. The author’s 19/19 assertions and timings are not our measurements. App-specific debug semantics are required; arbitrary release APKs are unsupported. No root license found, so this is a code case only.

Original sources: GitHub Source Source

Image inspection researchPublic code

Industrial image inspection with bounded classification and held-out calibration

Author / team: Fadel M. Megahed / Ying-Ju Chen

Input: An industrial inspection image, normal/defect descriptions and optional labeled reference images.
Jev decision: The hosted TypeSafe path sends image assets and the experimental image header, using Choice for normal/defective or primary-defect classification, with an optional multi-label Noul mode.
Next action: R code produces probabilities and predictions, fits Platt/isotonic calibration on calibration data and evaluates held-out test images with thresholds, producing paired comparisons and reports.

Evidence limit: MIT research project; the R package remains in design. A separate local-model path does not make TypeSafe weights open. Paper metrics/costs are author-reported; no data/weights downloaded, paid evaluation run or factory deployment verified. Dataset licenses are separate.

Original sources: GitHub Source Source

Note classificationPublic code

Bounded Obsidian note classification with confirmation for uncertain pairs

Author / team: Matteo Andrade Boschi

Input: A user-triggered note title, tags and truncated body; excluded folders are checked before reading.
Jev decision: One native Jev request uses Choice for fixed knowledge categories and subcategories. Code rejects values outside the taxonomy and combines category/subcategory probabilities to decide whether confirmation is needed.
Next action: Below threshold, a modal asks the user to choose among the top three pairs; existing classifications require overwrite confirmation. Accepted pairs update categoria/genero frontmatter, with a separate closed-wordlist tag command.

Evidence limit: 0BSD community plugin. No plugin installed, notes sent or marketplace availability verified. Note excerpts leave the device; the default threshold is an author setting, not an accuracy guarantee.

Original sources: GitHub Source Source

Agent assignment proposalsPublic code

Switchbite worker ranking and explicit holds

Author / team: BiteFoundry

Input: Host-supplied task, capability requirements, candidate workers, availability and preferences.
Jev decision: Code filters ineligible candidates, then Jev 1.14 Noul checks context sufficiency and Score judges fit/preferences for each candidate; code combines them with 0.7/0.3 weights.
Next action: After strict answer validation, returns an assign proposal or a reasoned hold. The host owns authorization, dispatch, state and orchestration; the MCP server itself launches no workers.

Evidence limit: MIT first public preview. The author validates only Windows x64 release builds, not macOS/Linux. No binary or live model run. Offline replays take precedence and must be bound to original tasks by the host; confidence measures distribution concentration.

Original sources: GitHub Source Source

Semantic code checksPublic code

Perch semantic code checks driven by Jev probabilities

Author / team: Lakeday

Input: Parsed code methods, related call context and configurable natural-language rules.
Jev decision: The configurable native TypeSafe System One path uses jev-latest for bounded code/rule questions, rejects missing answers and splits requests to service limits.
Next action: Code converts probabilities into issue/severity and rule-violation lists, preserving coverage and failures for ranking, rechecks and CI gates; incomplete checks must not be treated as passes.

Evidence limit: MIT multi-backend tool. Default Perch Cloud routing does not imply every call uses Jev; TypeSafe must be configured explicitly. Benchmarks include OpenAI and Jev, and one model’s results must not be attributed to the other. No repository uploaded or defect recall retested.

Original sources: GitHub Source Source Source

Internal company-agent routingAuthor post only

Sanity @s company-agent routing with a top-three user fallback

Author / team: Even Westvang / Rostislav Melkumyan / Knut Melvær

Input: The current Slack message (up to 8,000 characters), up to 20 prior thread messages and descriptions of published routable agents; the author reports 66 agents plus an @s help option.
Jev decision: Jev judges relevance/confidence among supplied candidates with the current thread agent identified; watched channels separately ask whether the agent should reply.
Next action: The highest-probability agent gets the task; below 0.4 confidence, the user chooses among the top three. The selected agent uses its tools/knowledge bases, with Temporal providing durable execution.

Evidence limit: Sanity’s primary engineering article, author post and TypeSafe recommendation were verified. This is a community company’s internal implementation, not a TypeSafe official project. No internal code, Slack access or independent accuracy evidence; 0.4 is the author’s policy.

Original sources: Sanity engineering Author X TypeSafe X

Agent runtime guardsAuthor post only

Composio Firewall condition checks on tool calls and results

Author / team: Karan Vaidya / Composio

Input: Tool name, arguments, returned content and user-defined blocking conditions; sessions with historical context also consider prior activity.
Jev decision: The author says Firewall combines Jev and Composio-tuned small models to assess actions and incoming information. Docs show condition matching and injection checks, without exposing per-check model allocation or primitives.
Next action: A matching before_execute check prevents the call and returns blocked; after_execute can withhold results from the agent, with injection checks limited to tool results.

Evidence limit: Vendor docs mark this experimental and available on paid plans; some contextual features remain marked Coming soon on the marketing page, so universal availability is not claimed. after_execute cannot undo execution, ZDR lacks historical context, and meta tools are outside hooks. No service activated, API called or security efficacy tested.

Original sources: Composio docs Author X TypeSafe X Product boundary

Search-result rerankingPublic code

Optional Jev reranking after local XERJ retrieval

Author / team: xerj-org

Input: A local-search query plus titles, text and explicitly permitted fields from a hit window; blank items are not sent.
Jev decision: The hosted Jev path builds an independent Noul per candidate, placing its document in that question’s instructions to judge relevance to the query.
Next action: The API stage reorders by valid answers, replaces _score and records unjudged hits. Degradable failures explicitly report applied:false and retain engine order; other errors follow the stated policy.

Evidence limit: Apache-2.0 community engine. Explicit rerank requests send the query/hit text out. Authors warn that raw probabilities are uncalibrated, so thresholds are not cross-query reliability guarantees. Separate local judges/compatible endpoints are not hosted Jev. No installation, index upload or BEIR retest.

Original sources: GitHub Source Source Source

Chinese moderation researchCode + author post

Chinese moderation evaluation with four questions and fixed thresholds

Author / team: Dylan Kong / MuShan-bit

Input: An author-built 825-item Chinese evaluation set mapped from public dataset labels; only methods and code were read, not sample text.
Jev decision: Selecting the jev provider calls TypeSafe System One: Choice selects a bounded category, Score rates severity and two Nouls detect attack/harm signals.
Next action: Code combines class probabilities and fixed thresholds into a verdict, reporting confusion matrices, F1 and latency in CLI/web views, with real providers distinguished from mock; it does not ban user content.

Evidence limit: MIT evaluation project with separate data licenses. Jev preview results are author-reported; mapped labels are not independently reviewed and the high violation share limits production inference. A labeled mock mode is available without a key. No API calls or evaluation reruns.

Original sources: GitHub Source Source Author X

Opinion structuring and researchPublic code

Durian opinion research from 18 judgments to variety comparisons

Author / team: Marton Szel / szia-ai

Input: 83 Chinese, English and Malay durian-opinion excerpts and fixed definitions for varieties, taste aspects and other questions.
Jev decision: Native hosted Jev answers 18 Noul, Choice and Score questions per opinion for mentions, sentiment, variety and comparisons; separate local models use Ollama.
Next action: Python normalizes answers, compares quality/time/cost against labels and converts ratings/comparisons into Elo tables and charts.

Evidence limit: MIT research code; opinion copyrights remain with original authors. Small samples, author selection and Elo construction limit conclusions. Rankings/costs are author-reported, not objective variety quality or our measurements. No excerpts copied, notebooks run, models downloaded or paid evaluations performed.

Original sources: GitHub Source Source Source

Coding-assistant model suggestionsPublic code

Model and effort suggestions for Claude drafts

Author / team: Prad Biswas / pbswimmer3

Input: A draft prompt; truncated recent user prompts and the last assistant reply are attached only when judged to continue earlier work.
Jev decision: One System One-format request asks about bounded model/effort options, sensitive changes, explicit model instructions and continuation; policy may make a context-enriched follow-up.
Next action: Code applies thresholds, step-up rules and explicit user choices to show a suggestion card; users change the model manually. A first-message card does not imply the running model has changed.

Evidence limit: Apache-2.0 community mod. Merge Gateway is default, TypeSafe direct is optional and Kev is independent. Scrubbing covers obvious patterns, not complete confidentiality. Accuracy/costs were not retested; no mod installed, sessions read or models called.

Original sources: GitHub Source Source Source

Semantic convention checkingPublic code

judgelint paired convention questions and line-range results

Author / team: JP Camara

Input: Numbered source files, README conventions and optional context, with questions normally targeting 40-line windows.
Jev decision: The TypeSafe configuration uses native System One Nouls, asking whether a convention is broken and followed/inapplicable, then inverting the latter into violation scores.
Next action: Code combines question/optional multi-model scores, classifies violation/uncertain and other states, and emits line ranges, JSON/SARIF or CI exit codes; skipped/refused items remain explicit.

Evidence limit: MIT multi-backend tool; other model results are not Jev results. Rule wording, judge family and in-code judgehint comments affect outcomes. This is not deterministic proof or security authorization. No binary installed, source uploaded or author samples retested.

Original sources: GitHub Source Source Source Source

Conversation-corpus researchAuthor post only

AI-dialogue research with Jev classification and human reading

Author / team: Eduardo Bergel

Input: The author’s 437 generated conversation records and 11,013 messages; only the public author article was read.
Jev decision: The author uses TypeSafe Jev for 53 classifier questions per message, including 24 broad domains, and six lenses on 1,000 messages; exact API primitives were not verified.
Next action: Aggregated topic distributions and correlations help select passages for human reading and inform later validation/control experiments.

Evidence limit: Author-article evidence only; repository code and raw conversations were not inspected/copied, so no project entry is added. Topic scores are not consciousness evidence. Imbalance, dependent messages, prompt framing and length bias limit findings; costs are author-reported.

Original sources: Author X article

Workflow routing examplePublic code

ADK workflow branches driven by Jev classifier answers

Author / team: Google ADK contributors

Input: A support-ticket text in the docs, or caller-supplied JSON, with explicit instructions and allowed answers.
Jev decision: TypesafeClassifier converts Choice, Binary and Score to native Jev choice, noul and score, then checks types, labels and numeric ranges.
Next action: ClassifierNode emits a Choice label or Binary-threshold route while forwarding unchanged input; graph validation checks branch coverage and invalid/missing answers raise errors.

Evidence limit: Apache-2.0 Google SDK integration, not a TypeSafe official project. Classifier nodes remain experimental labs APIs. The generic ticket sample defaults to Gemini; docs explicitly show TypeSafe wiring. No install, Jev call, customer workflow or tool authorization executed.

Original sources: GitHub Source Source Source

Skill recommendationPublic code

Skillbox relevance recommendations within an authorized skill catalog

Author / team: Kitze

Input: A task and the authenticated scope’s active, authorized skill descriptions/revisions; oversized catalogs explicitly fall back.
Jev decision: Optional direct TypeSafe evaluates each candidate with a Score on a bounded 0–4 relevance rubric; user-configured gateways are also supported.
Next action: Code validates all scores and returns candidates scoring at least 3, ranked/paginated. Scope/catalog changes invalidate results, failures explicitly fall back to search, and no skill is executed.

Evidence limit: MIT self-hosted tool. The 0–4 rubric is uncalibrated, not accuracy. Tasks and authorized descriptions go to the selected provider. Missing-key/timeout fallback is not Jev success. No install, private-skill access, paid benchmark or production-quality validation.

Original sources: GitHub Source Source

Paper screening and digestsPublic code

Paper digest with Jev interest screening before ranking and summaries

Author / team: Monkeypox966

Input: New arXiv titles, abstracts and categories plus configured interest propositions/exclusion conditions.
Jev decision: Native TypeSafe Jev is the default, answering interest/exclusion Nouls per paper. Validated answers become max or noisy-or composite scores.
Next action: Code applies relevance/exclusion gates, separately checks institution preferences and selects Top K for DeepSeek summaries. Preview writes reports; send mode uses pending-delivery records and deduplication before email.

Evidence limit: MIT project. Institution preferences/composite scores are not objective paper quality or calibrated probabilities. No model calls, Actions runs, mail sending or live delivery verified. Other compatible backends require explicit configuration; contract tests do not prove all live integrations.

Original sources: GitHub Source Source Source

Personal email triageCode + author post

Gmail triage with evidence gates and human-corrected examples

Author / team: Miguel Garcia

Input: Sender, subject, optional truncated body, personal preferences and up to six relevant human-corrected examples.
Jev decision: Native Jev Choice selects Spam/Ignore/Important and Noul judges evidence sufficiency; code validates distributions and gates Review on probability, confidence and evidence.
Next action: Preview stores predictions; apply separately checks versions/human labels before labeling. Learning reuses corrections without training weights; optional cleanup then archives or trashes messages.

Evidence limit: Experimental personal workflow; root license unconfirmed, so code case only. process.sh enables cleanup by default: Spam goes to Trash and Ignore/Review are archived. Review does not imply inbox retention. Excerpts leave the device. No mailbox access, Gmail authorization, classification or accuracy test performed.

Original sources: GitHub Source Source Author X

Image-localization prototypePublic code

Jev Live image-box snapshots gated by presence judgments

Author / team: mu1ze

Input: A user-triggered JPEG/PNG snapshot with up to eight target descriptions; page load itself starts neither camera nor upload.
Jev decision: The server calls Jev 1.14’s experimental image interface, pairing Noul presence and Box localization questions per target.
Next action: Code suppresses boxes below 0.7 presence or with invalid coordinates/confidence and displays the minimum confidence. Browser overlays expire four seconds after capture and late results are discarded.

Evidence limit: No project license found; public code case only. Images go to a hosted service, not on-device vision or continuous tracking. 4 Hz is a target cadence, not guaranteed completion rate. Author tests use fake cameras/fixtures. No camera opened, images uploaded, models called or quality retested.

Original sources: GitHub Source Source Source

Audiobook pause annotationAuthor post only

Booksmith sentence decisions followed by paragraph pause review

Author / team: NeuralCatAccel

Input: Sentence boundaries/paragraph context from the author’s DRM-free ebooks plus measured silence and safe edit positions.
Jev decision: The author says Jev selects bounded pause roles/paragraph plans, proposing sentence timing then retaining, removing or adding beats without rewriting the text.
Next action: Plans become necessary extra silence alongside local Kokoro chapter narration, with separate human approval/listening gates for pronunciation suggestions and repairs.

Evidence limit: Author-post evidence, not our end-to-end verification. The public client needs a configured /Jev/decide gateway whose TypeSafe adapter was not verified. The project explicitly has no selected license, so no open-source entry. Windows-first, hosted timing off by default. No books/audio accessed, install, model call or Plex verification.

Original sources: Author X Source boundary Gateway client (adapter unverified)

Contact-form triageAuthor post only

Four-way contact-form classification with fail-open mail delivery

Author / team: Yuki Matsukura / matsubokkuri

Input: Form category, name, email and message with site-business context; only the public technical article and redacted illustrations were read.
Jev decision: One native Jev Choice distributes probability among legitimate inquiry, sales, misdirected and junk, with business context in instructions/criteria.
Next action: At sales+junk >=0.8, code tags subjects [SPAM], with a separate misdirected tag. All mail remains delivered; API failure sends it as unclassified. The author also implements automated/manual external spam reporting.

Evidence limit: Author-article evidence only; the 181-item retrospective and per-call costs are author-reported/estimated, without independent billing or deployment verification. The author discloses conflicts with external reporting requirements and hard-to-retract distributed false reports; that portion is not a recommended workflow. Personal fields leave the device. No original customer data accessed, forms submitted, mail sent or identities reported.

Original sources: Author technical article Author X

Structured-document examplePublic code

ContextGem: probability-bearing Boolean and label extraction

Author / team: Sergii Shcherbak / Shcherbak AI

Input: Example service-agreement paragraphs and predefined concepts for termination, termination without cause and notice form.
Jev decision: Via LiteLLM Decisions, typesafe/jev-latest answers paragraph-membership predicates, Boolean concepts and closed-label questions rather than generating clause text.
Next action: The framework thresholds paragraph membership and Boolean values, retaining probabilities; multiclass labels use the most probable option and are stored in document extracted_items.

Evidence limit: Apache-2.0 community framework with multiple providers. The default 0.5 threshold applies to the relevant predicates, not a universal label-confidence gate. Sample probabilities are author illustrations, not legal findings or independent measurements. No installation, real contracts, result logs or model calls.

Original sources: GitHub Source Source Source

Chess decision experimentPublic code

switch: choosing the next chess move from a legal menu

Author / team: Onur Solmaz

Input: A text board, move history and legal moves enumerated by chess.js, with a reduced history view when the window is exceeded.
Jev decision: The example uses pi-ai’s typesafe/jev-latest classifier adapter to choose a legal move or resignation with Choice, retaining option probabilities.
Next action: Code plays the selected move followed by a seeded random opponent, or runs self-play. It records traces, moves and the outcome; reaching 200 steps is unfinished.

Evidence limit: MIT community framework with separately BSD-licensed pieces and support for other decision models. Rules constrain legal moves; this establishes no Jev playing strength or measured win rate. No installation, model downloads, games or hypothetical ticket workflow executed.

Original sources: GitHub Source Source Source Source Source

Classification calibration studyPublic code

Banking-intent research: Choice, Noul and simulated action thresholds

Author / team: Ankur Tomar

Input: Public BANKING77 messages: a seven-intent slice, all 77 labels, and out-of-schema examples from excluded intents.
Jev decision: Native /v1/systemone Choice picks an intent, with independent Nouls for individual intents in the same request; other experiments compare terse and three-shot criteria.
Next action: Scripts compare labels to compute accuracy, calibration and Choice/Noul disagreement, then use 0.9 to count simulated automatic decisions and out-of-schema errors; no banking operation is performed.

Evidence limit: MIT code with separately CC-BY 4.0 data. Open scikit-learn interface experiments are distinct from actual Jev experiments. README results and costs are author-reported, and the threshold is no general guarantee. No raw responses, accounts, dataset downloads or paid reruns.

Original sources: GitHub Source Source Source

Walking-route prototypePublic code

Jev Walker: bounded corner-exit selection with manual overrides

Author / team: Keanan Koppenhaver

Input: A bounded exit menu, relative directions, block lengths, walking progress and home compass; the public model menu omits raw coordinates and graph-node identifiers.
Jev decision: Native TypeSafe or OpenRouter Decisions wiring uses Jev Choice over exit IDs, checking that the returned ID belongs to the current menu.
Next action: The simulator updates the route. The phone prototype displays the exit, waits for arrival and allows cannot-walk overrides or ending; repeated failures leave it waiting for retry.

Evidence limit: Public code with unconfirmed root/package licensing, so no verified-license project entry. Current README completion tables concern random/heuristic choosers, not Jev field results; simplified maps do not establish safe passage. No home configuration, GPS logs, location, tunnels, walks or model calls accessed.

Original sources: GitHub Source Source Source

Semantic browser testingPublic code

Decisium: Jev selects controls, code checks page values and states

Author / team: Andrei Letenkov

Input: Gherkin steps, visible page text/control trees, and program-enumerated elements, actions and candidate input values.
Jev decision: Native jev-1.14.0 Choice selects targets, actions and check kinds, while Noul checks step completion; large candidate sets are narrowed in batches.
Next action: Playwright performs actions and code compares expected text, values and states, reporting ambiguity/unverifiability separately. Cassettes retain resolutions for model-free replay and can flag UI_CHANGED.

Evidence limit: MIT community tool. Subjective assertions default to UNVERIFIABLE; explicit --judged delegates them to Jev with separate results, so not every assertion is code-proven. Live step/page text leaves the device; literal passwords can too, so use $NAME placeholders. Model-free replay does not establish current Jev quality. No installation or third-party site actions.

Original sources: GitHub Source Source Source Source

Request-screening experimentPublic code

vigilant-heron: rules first, then Jev shadow request screening

Author / team: coo-quack

Input: Copies of HTTP requests not decided by fixed rules, with Cookie/Authorization fields removed and body length bounded; client data is isolated under untrusted_http_request.
Jev decision: One native Jev request asks two Nouls for attack and AI-directed instructions, plus a category Choice, with answer-type and probability-range checks.
Next action: Site thresholds drive forwarding, 403 blocking or redirection. Shadow records would-have actions while forwarding; model errors default to allow, with configurable fail-closed paths.

Evidence limit: Early MIT community project explicitly unvalidated on real traffic; the author advises shadow first. Field redaction cannot guarantee all private content is removed. Alternative Clef/Strands backends and e2e stubs are not Jev measurements. No proxy launch, attacks, real logs or model calls.

Original sources: GitHub Source Source Source Source

Presentation-checklist tutorialPublic code

Official Intelliprompter: a monotonic checklist from coverage scores

Author / team: TypeSafe AI

Input: An accumulated presentation transcript and descriptions of unchecked talking points; the cookbook demonstrates six authored transcript increments.
Jev decision: Each pending criterion gets a five-level Score over the same full transcript; adding one maps SDK scores from 0–4 to the UI’s 1–5 scale.
Next action: Code adds criteria scoring at least 2.5 to a covered set and omits them from later requests, preserving checks; Jev does not store checklist state.

Evidence limit: TypeSafe’s official cookbook. The 2.5 gate is a local coverage threshold, not confidence, and an incorrect check is not automatically revoked. Microphone/ElevenLabs integration is omitted in favor of text/cache replay; published numbers are the author’s jev-1.13.0 sample, not independently reproduced. No microphone or paid API calls.

Original sources: Official cookbook

Mail-list organizationPublic code

Emc²: mail category, relevance and fixed reason labels

Author / team: Zns-Nexus / collection-of-things

Input: Sender address, subject and preview, with user sender rules taking priority.
Jev decision: One native Jev request uses Choice for Important/Other, a three-level relevance Score and another Choice for fixed reasons such as needs-reply.
Next action: Code rounds the 0–2 Score and adds one for display, storing the sorting on local mail records. Provider failure retains local sorting and reports an error rather than counting as Jev success.

Evidence limit: MIT community mail client with other providers and local rules. Display levels are not confidence; sender and preview still leave the device. No installation, private inbox access or mail sending; storage/platform claims were not independently tested.

Original sources: GitHub Source Source

RAG-routing courseworkPublic code

Agentic Router: routing sub-queries to three knowledge sources

Author / team: jacinta-escaffi

Input: A user question or model-split sub-query, with OpenAI docs, two companies’ 10-K filings and the internet as candidate sources.
Jev decision: Optional route_query_jev uses a native SDK Choice over three fixed sources, passing the question as state.
Next action: When the Jev router is explicitly injected, each part is retrieved/answered and its citations combined; a Jev error falls back to the internet route.

Evidence limit: Public notebook with unconfirmed root licensing, so no project entry. The default router and separate RBAC/cache section still use GPT, not Jev authorization; course data is external. The 20-question results/costs are author-reported/estimated. No notebook outputs, corpus downloads or model calls.

Original sources: GitHub Source

Browser-guidance prototypePublic code

Jev Guide: highlight the next step for the user to click

Author / team: some45bucks

Input: A user goal, clickable page elements and attempted paths, with batch shortlisting for large candidate sets.
Jev decision: Native TypeSafe wiring uses Choice for the element and Nouls for completion, login needs, irreversibility and goal match; large pages use Score shortlisting.
Next action: It draws highlights, uncertain alternatives and final-step warnings; the user clicks, types and submits, and stale-page answers are discarded.

Evidence limit: Stage-4/7 public code without confirmed root/package licensing, so no project entry. Synthetic fixtures include wrong turns; confidence and red warnings guarantee neither correctness nor safety. Only native wiring was reviewed, not OpenRouter compatibility. No extension installation, permission expansion, password changes or real cancellations.

Original sources: GitHub Source Source Source

Agent tool routingPublic code

Feather Wand: Jev selects the JMeter agent’s initial tool pack

Author / team: NaveenKumar Namachivayam / QAInsights

Input: A request with attachment bodies removed and the routing view capped at 4,000 characters; user-entered sensitive text can remain.
Jev decision: Native Jev Choice selects inspection, plan editing, run/diagnosis, correlation, plan files or complex/unclear, checking labels and probabilities.
Next action: A confident route focuses the tool pack and displays a route card; low confidence, complexity or unavailable service falls back to all tools for the downstream agent.

Evidence limit: MIT community plugin with routing off by default, a default 0.75 gate and alternative backends. Tool-pack selection is not authorization; mutations/runs depend on host confirmation settings. No JMeter installation, load tests, logs or model calls.

Original sources: GitHub Source Source Source

Lightpanda: Jev selects three login-form controls

Author / team: Lightpanda

Input: Controls available on the demo login page; the complete input fields are not disclosed.
Jev decision: The author says Jev selects the username field, password field and submit button from existing page controls.
Next action: Lightpanda’s agent uses the selected controls in the login flow, and TypeSafe recommended the demonstration.

Evidence limit: Author post and official recommendation only, describing a Lightpanda community integration. The 0.53-second/two-call figures are author demo numbers, not a general success rate. No branch, question-type/failure-path, credential or live-login verification; no verified-license project entry.

Original sources: Author X TypeSafe recommendation

Live-call visualization demoAuthor post only

Conversation X-Ray: colored phrases and six emotion meters

Author / team: ElevenLabs Developers

Input: Phrase-by-phrase call content with a live transcript visible in the demo; no voice was submitted this run.
Jev decision: The author attributes emotion judgments to Jev; the UI shows frustration, happiness, surprise, uncertainty, urgency and neutral, without published question types, scales or thresholds.
Next action: Phrases are color-coded and meters change during the call; TypeSafe recommended the original demonstration.

Evidence limit: Backfilled from the September 24 author post and 27-second demo, not a TypeSafe-owned project. Source code, whether vocal tone reaches Jev and retention were not verified; no-storage is an author claim. No independent accuracy/latency measurement, microphone access, service calls or user-call uploads.

Original sources: Author X Author demo reply TypeSafe recommendation

Interactive-world prototypePublic code

Tiny World: selecting fictional island residents’ actions and targets

Author / team: hank-go1

Input: Scene instructions, recent history, resident traits, positions and needs such as hunger and energy.
Jev decision: Optional Jev via OpenRouter alpha/decisions selects actions, targets and scene state with Choices, plus a flight Noul converted at 0.5.
Next action: The server validates answer options, numbers and structure before the UI replaces world state; movement, collisions and rendering remain local, and errors retain the scene.

Evidence limit: The UI defaults to OpenAI and town mode is not Jev. Only the optional island 1.13 wiring was reviewed, without model calls. Licensing explicitly awaits owner approval: LICENSE.proposed is not an active grant, so no open-source project entry. Automatic calls and cost estimates were not tested.

Original sources: GitHub Source Source Source Source

Constrained generative artPublic code

Abstract art: deciding which renderer fields a prompt needs

Author / team: carollia-99

Input: An art prompt of up to 500 characters and the fixed Canvas renderer’s capabilities.
Jev decision: Gateway Jev uses Choices for visual direction, four-level Scores for field-family relevance and a separate Choice between fixed-spec and custom-code routes.
Next action: Optional fields are asked only at relevance 1.5 or above; completed/reconciled specs feed a seeded Canvas renderer. Only a custom-route probability of at least 0.65 sends the task to another model for JavaScript and Sandbox execution.

Evidence limit: Jev generates neither pixels nor JavaScript; constrained grammar, code reconciliation and other models contribute. Root licensing is unknown, so this is a code case only. Experimental SDK/API, Sandbox, speed, cost and determinism were not independently tested.

Original sources: GitHub Source Source Source Source

Model-routing examplePublic code

ADK: a two-choice Jev workflow for Gemini model routing

Author / team: sjaffry

Input: Task text entering an ADK workflow, with fast and powerful as its two tiers.
Jev decision: TypesafeClassifier targets jev-latest with a Choice for the least costly adequate tier; Google’s adapter source confirms conversion to native /v1/systemone.
Next action: ClassifierNode records the decision under jev_routing; Workflow dispatches the label to gemini-2.5-flash or gemini-2.5-pro.

Evidence limit: Community code example with unconfirmed root licensing, so no project entry. There is no independent cost, accuracy or calibration evidence. No ADK installation, CLI execution or model calls; selecting powerful is not a safety guarantee for consequential tasks.

Original sources: GitHub Source Google ADK adapter

News-subscription filteringPublic code

hndelegate: decision-tree filtering before Telegram delivery

Author / team: uint4096

Input: Extracted content of new HN stories and configurable tree questions, options and gates stored in SQLite.
Jev decision: A native Jev request batches tree Choices/Nouls; Choices include None, and code checks selected probability and minimum confidence.
Next action: Code recursively looks for a complete passing branch and sends title/article/discussion links to the configured Telegram destination when a root tree matches; processed stories are skipped.

Evidence limit: GPL-3.0 community project reviewed through source and licensing. Tree gates do not verify factual truth. No local database access, Telegram connection, messages or independent scheduled-run testing.

Original sources: GitHub Source Source Source

Agent-context pruningPublic code

OpenCode: two-stage pruning of MCP and skill descriptions

Author / team: theroich

Input: The current user prompt and candidate MCP server, tool and skill descriptions.
Jev decision: Batched Nouls first judge server relevance, then remaining tools and skills, with default retention gates of 0.35 and 0.55.
Next action: The context hook changes only the current request’s catalog, instructions and tool map. Timeouts/errors retain the original request, and missing scores do not actively prune.

Evidence limit: MIT community plugin. Pruning changes no registry, connection or execution permission and is not an authorization firewall. The default OpenCode proxy endpoint and host integration were not tested; fake-jev is deterministic keyword matching. No hooks, host permission changes or paid calls.

Original sources: GitHub Source Source Source Source

Synthetic mail-agent guardrailsPublic code

Mail demo: Jev checks inbound text and drafts; code enforces gates

Author / team: lorenzorama

Input: Revealed mail text, or a user task, proposed draft and read snippets, with author-defined demo addresses and secrets.
Jev decision: Jev Nouls check AI-directed instructions, whether a draft serves the request and whether it discloses a read secret; contact authorization remains in code.
Next action: Mode A observes; mode B quarantines gated mail and writes only allow drafts to local JSONL. Secret disclosure, ambiguous scope or provider errors block/escalate; no mail is sent.

Evidence limit: MIT talk demonstration, not a verified injection defense. Gates, a two-second timeout and a three-draft limit are inspectable. A separate Score evaluation’s median is not model confidence. No user mail, access codes, replay bodies or model execution.

Original sources: GitHub Source Source Source

Cited-evidence rerankingPublic code

Pi search: retrieve evidence, then optionally judge it with Jev

Author / team: Gagan Devagiri / GaganSD

Input: The query and each candidate’s title, URL and full cited text, judged optionally after retrieval.
Jev decision: Pi classifier bool questions cover answer relevance, off-topic content, self-containment and set sufficiency, plus a five-category safety Choice; an available Jev model must be explicitly pinned.
Next action: Code reranks with default weights 0.45/−0.30/0.25 and suppresses a non-safe category only at probability 0.75. Uncertainty remains marked. An eight-second judging failure retains retrieval with a warning; removed evidence invalidates a previous positive sufficiency claim.

Evidence limit: MIT community extension with thorough retrieval and judging both off by default; fast searches do not judge. All candidates reach the selected external provider before suppression, which is not a security firewall. No installation, Pi auth/config access, private code or performance testing.

Original sources: GitHub Source Source Source Source Author X

People-search demonstrationAuthor post only

Monid: filter people-search candidates before enrichment

Author / team: Shengkun Ye / Monid

Input: A people-search request and candidates from multiple data vendors; the demo shows Jev selecting a subset of sources.
Jev decision: The author attributes candidate retention to Jev before enrichment, without publishing question types, retention criteria or thresholds.
Next action: Only retained candidates proceed to enrichment; TypeSafe recommended the original demo.

Evidence limit: Author post and demo only, not a TypeSafe-owned project. Per-lead cost, zero markup and open-source claims are unverified author statements; code, licensing and personal-data handling were not checked. No real-person searches, purchases or contact messages.

Original sources: Author X Author product reply TypeSafe recommendation

Real-time voice-turn demonstrationAuthor post only

Voice turns: using transcript and recent context to detect completion

Author / team: Jay F / SoCalJayF

Input: A live transcript and recent conversation for semantic end-of-turn detection in an Agora ConvoAI integration.
Jev decision: The author uses Jev to decide whether the user has actually finished, distinguishing hesitation, unfinished thoughts and brief pauses; exact question types and gates are undisclosed.
Next action: The decision feeds real-time voice turn handoff; the author provides an 85-second demo and repository reply, later recommended by TypeSafe.

Evidence limit: Backfilled from the September 24, 2026 original post. Post evidence only: implementation/licensing, whether raw audio reaches Jev, latency and quality were not verified this run. Not a TypeSafe-owned project; no microphone, call uploads or Agora connection.

Original sources: Author X Author repository reply TypeSafe recommendation

Agent-completion reviewPublic code

Footwork: checking overall and per-requirement completion evidence

Author / team: Thomas Main / Tom-R-Main

Input: The task, requirements, current observed text, proposed answer and optional trajectory/current-run effect evidence.
Jev decision: A native System One request batches Nouls for completion, each unmet requirement and answer necessity, optionally classifying requirements as historical action, current state or answer.
Next action: Code assigns accept/verify/reject, initially requiring completion at least 0.80 and maximum unmet at most 0.30; absent visible facts, a required answer or deterministic effect evidence can still downgrade acceptance.

Evidence limit: MIT community computer-use framework reviewed at pinned source. Gates and author experiments are not independent reliability/security evidence and never replace user authorization. Its separate decisions.py is a non-Jev shadow transport. No driver installation, local traces, native-app control or model calls.

Original sources: GitHub Source Source Source

Ticket-classification learning projectPublic code

Ticket triage: three question types and local human-handoff rules

Author / team: nacknime-official

Input: Ticket subject and body read by a background worker; Kafka events carry IDs/status rather than the text.
Jev decision: Jev uses a complaint Noul, a five-team Choice and a four-level urgency Score, with explicit rules separating dissatisfaction from actual impact.
Next action: Category confidence below 0.60, urgency confidence below 0.50 or category other routes to needs_human; mid-band complaint probability only adds a flag. Status/audit updates feed SSE through a transactional outbox.

Evidence limit: The default is fake until Jev is explicitly selected. Its older OpenRouter route and native success contract were not independently tested; the author’s 100-item labels are unreviewed drafts, so metrics are provisional claims. Root license unknown: no project entry. No Kafka/Postgres, ticket access or paid probe.

Original sources: GitHub Source Source Source Source

Game-monster decisionsPublic code

Donjon: monsters choose feasible actions and prewritten lines

Author / team: game-design-projects

Input: Monster traits/state, party, player speech and recent events, with input text and candidate counts bounded at entry.
Jev decision: Jev Choices select among currently feasible actions, attack targets and prewritten lines, alongside willingness judgments, through native TypeSafe or OpenRouter alpha wiring.
Next action: Local emotion, feasibility and joining rules can reconcile choices before game.gd applies attacks, defense, conversation or joining. Provider errors make monsters hesitate and stale-fight responses are discarded.

Evidence limit: Community Godot prototype with unknown root licensing, listed only as a code case. Guided encounters may force joining, so not every behavior comes from Jev. No game execution, microphone, platform qualification or demo reproduction.

Original sources: GitHub Source Source Source Source

Video-feed filteringPublic code

YouTube filtering: local hide/dim policy after Jev judgments

Author / team: Vladislav Karachkov / Vlad0n1m

Input: Video-card title, channel, duration and a description excerpt, without video pixels or transcripts.
Jev decision: One native Jev request asks clickbait and hype Nouls plus a four-level 0–3 substance Score.
Next action: Normal mode hides/dims with reasons when either Noul reaches 0.70 or substance falls below 1.5. Raw answers are cached by video ID so threshold changes need no new call; the channel allowlist wins.

Evidence limit: MIT extension whose Shorts hiding/redirects are separate local rules. Gates are not calibrated on real feeds; music or useful videos with exaggerated titles may be removed and caches can age. No installation, personal viewing history, browser permission changes or API calls.

Original sources: GitHub Source Source Source

Video planning and groupingPublic code

Shorts planning: nine typed judgments, local ranking and format blueprints

Author / team: bigmo6286

Input: Short-video title, description, tags, channel, duration and available transcript, explicitly marking missing transcripts.
Jev decision: One native SDK call batches three Choices for format/topic/hook, three Scores for hook strength/replicability/evergreen value and three Nouls for language accessibility/promotion/clickbait risk.
Next action: rank.py weights velocity, engagement and normalized Scores, excluding by language/promotion gates. analyze.py groups by format/topic, caps each channel’s contribution and marks hard-to-reproduce stretch blueprints.

Evidence limit: Code review only with unknown root licensing, so no project entry. clickbait_risk is asked but not directly used for this ranking’s exclusions. Judgments prove neither facts, rights nor platform compliance. Downstream scripts/images/voice are not Jev generation. No cookies, video retrieval, production or uploads.

Original sources: GitHub Source Source Source

SDK-advice examplePublic code

SwiftAgent: three question types produce review advice only

Author / team: ChainBow / OtohaCo

Input: A synthetic double-charge request with billing, responsible-team and review-timing questions in one call.
Jev decision: Jev supplies a billing Noul, support/billing Choice and two-level urgency Score; the adapter checks options, numbers and response structure.
Next action: Code uses illustrative 0.5 gates to print a ReviewProposal containing queue, urgency and billing-review flags; it neither executes tools nor grants permission.

Evidence limit: The MIT SDK’s RC example defaults to a fixture; only explicit live opt-in plus a key calls Jev, so fixed answers are not live success. No Swift installation, credentials, model calls or production-host qualification; sample gates are not business calibration.

Original sources: GitHub Source Source

Official primitive-composition cookbookPublic code

Shopping cart: shrink item options, then assemble fields

Author / team: TypeSafe AI

Input: One cafe order and a four-item menu with known per-item fields; the example orders a latte and a blueberry muffin.
Jev decision: Each Choice selects a remaining item or nothing_else; one batched Choice request per found item then fills known fields such as size and milk, with unspecified available.
Next action: Code removes and saves each selected item, stops at the sentinel or six-request cap, and assembles fields into a cart. Items without fields skip the second-stage call.

Evidence limit: Official documentation and its public example-cache path were checked without API calls or downloading the cache. Outputs are official reports. Each menu item appears at most once and there is no quantity field, so repeated items and quantities are not handled by this example.

Original sources: Official cookbook

Author-reported voice agentAuthor post only

Voice anticipation: prewarm likely intent paths during streaming transcription

Author / team: Allie the Icon / Allie Laabs

Input: Word-by-word transcript text from a custom STT pipeline before the speaker has finished.
Jev decision: The author describes Jev judging likely narrow intent-handler paths as additional transcript text arrives.
Next action: Prewarm likely paths; the follow-up says to rejudge after each word and require two consecutive approvals, illustrating a lamp set to 50% before the entire utterance ends, subject to risk/reversibility.

Evidence limit: Original, system-description and follow-up posts display 2026-10-23 02:11, 01:25 and 08:55 JST respectively, with quote times distinguished. Author report only: full options, probability gates, cancellation/concurrency and early-execution protocols remain unpublished. Two approvals do not establish safe authorization, reproduced latency or direct audio processing.

Original sources: Author post System description Author follow-up

Access-log behavior judgmentsPublic code

Custos: judged suspicious-IP windows feed a blocking pipeline

Author / team: george-amir / Custos contributors

Input: Suspicious per-IP access windows, request samples and sanitization flags after L1 screening, batching multiple actors into compact state.
Jev decision: Native System One asks a should_ban Noul and predefined threat-class Choice per IP, checking missing answers, labels and probability values.
Next action: For non-benign classes, code applies the configured maliciousness gate, or probability at least 0.70 plus class confidence at least 0.95, then records an expiring ban for firewall enforcement. Failed batches remain pending and signature caching has separate checks.

Evidence limit: MIT community Rust project reviewed at pinned source, with an offline mock. Author memory/load data do not establish model accuracy. No daemon, real logs, firewall changes or model calls; gates do not prove false-block rates or adversarial reliability.

Original sources: GitHub Source Source

Regulatory and security news filteringPublic code

GRCInsight: three relevance labels with per-article fallback

Author / team: ricomanifesto

Input: Up to 200 title characters and 500 content/summary characters per article plus GRC focus areas, in batches of at most twelve with a byte budget.
Jev decision: A Jev Choice through OpenRouter alpha selects relevant, irrelevant or insufficient_evidence, validating served model, question IDs and probability distributions.
Next action: When the pilot is enabled, usable relevant items enter the report selection and irrelevant items are excluded; uncertain items use the existing model. Shadow mode only records comparisons, off preserves the old path, and another model still generates the report.

Evidence limit: MIT source and its consumer were checked; an optional pilot is not asserted to be the production default. Probability gates and author comparisons are not site measurements. Relevance does not establish legal applicability or severity. No private articles, report runs or paid probes.

Original sources: GitHub Source Source

Cultural-entertainment UI routingPublic code

Liuyao UI: Jev classifies questions and screens risk

Author / team: masonweb3

Input: A user question capped at 200 characters with server validation and rate limits; chart calculation uses local deterministic code.
Jev decision: One native request contains a topic Choice and four Nouls for self-harm, emergency, gambling and sincerity. Topic preselection requires confidence at least 0.6.
Next action: Code routes in order through self-harm blocking, gambling refusal, emergency notice, rewrite and manual/preselected topic. Timeout or no key returns an unflagged manual-selection fallback.

Evidence limit: Source-available rather than open source: code is PolyForm Noncommercial and original copy has separate CC BY-NC-SA terms. Listed only as a code case. Gates use author samples and failure fallback loses semantic screening. No live effectiveness test; Jev predicts neither fortune nor medical, legal or investment outcomes.

Original sources: GitHub Source Source Source

Community synthetic-sample evaluationPublic code

Job-by-job checks: synthetic channel judgments against expected actions

Author / team: WeBuildDatabases

Input: Fictional Postgres-help channel messages, channel purpose and prewritten core/edge expected labels.
Jev decision: Pinned jev-1.14.0 uses a native request with a message-category Choice, hostility Noul and private-information Noul.
Next action: Hostility at least 0.7 selects hide, otherwise private-information probability at least 0.7 selects blur, then category rules choose display/highlight. Tests record action agreement, tokens and latency.

Evidence limit: This is a synthetic test, not live chat enforcement. README sample counts, costs and accuracy are author reports; cached replay is not live success. Root licensing is unknown, so no project entry. No scripts, .env access, result-cache downloads or paid calls.

Original sources: GitHub Source Source Source

Game-action selection prototypePublic code

DecideX: select a legal 2048 move and await board settlement

Author / team: dengyie

Input: A 4×4 board, score, legal moves and local depth-two lookahead values form state for move_direction.
Jev decision: The TypeSafe adapter sends a System One Choice over legal directions, and the engine applies legality and configured confidence gates.
Next action: The program executes the selected direction, waits for board settlement and records score gain. Model/gate failures fall back to Expectimax; hybrid mode invokes Jev periodically.

Evidence limit: MIT code case without browser attachment, account-pool access, gameplay or latency reproduction. The framework also has mock/multi-provider paths. Calibration, win-rate and industrial claims are author statements; some turns are heuristic rather than Jev. No quota-circumvention use is endorsed.

Original sources: GitHub Source Source Source

RAG evidence filteringPublic code

vaultgate: passage relevance followed by evidence sufficiency

Author / team: Bagusdevaa

Input: A query, hybrid-search candidates and graph-expanded note passages, with a character budget for generation context.
Jev decision: Jev through OpenRouter alpha asks a relevance Noul per passage, then a sufficiency Noul over the final context-budgeted set, using byte-capped batches.
Next action: Configured initial gates are 0.2 for relevance and 0.5 for sufficiency. Insufficient evidence triggers one retry without retrieval filters and with forty candidates, still applying the Jev gate, then abstention without generation if still insufficient.

Evidence limit: Source and consumer reviewed, with unknown root/pyproject licensing, so listed only as a code case. Gates and the author’s sixty-question comparison are not site calibration; response parsing mainly uses indexing and float conversion. No real notes, Qdrant, model downloads or API calls.

Original sources: GitHub Source Source Source

Agent action routingPublic code

JevRouter: four judgments feed separate policy and verification

Author / team: HangChi / SongHangChi

Input: The goal, execution state and descriptions of registered candidate tools; code registers tool risk classes.
Jev decision: One native System One request asks a next_action Choice, a 0–4 risk Score and Nouls for confirmation and deeper reasoning.
Next action: Policy handles controls and unregistered tools first, then requires confirmation for write/external tools. Read tools use gates for execution, confirmation or LLM delegation. Separate completion checks follow, and repeated finish disagreement goes to a human.

Evidence limit: MIT community framework; fifty-three-case accuracy/latency are author reports and tests use HTTP mocks. web_search/send_mock_email are local mocks. No API startup, real-tool grants or safety reproduction; model probabilities confer no permission.

Original sources: GitHub Source Source Source Source

Group-chat response gatingPublic code

BetterChat: three probabilities gate group-chat participation

Author / team: AS214933

Input: Group messages passing local command, length, rate-limit and cooldown checks, with recent context and bot identity.
Jev decision: One native Jev request asks addressed_to_bot, open_question and already_answered_by_bot Nouls, strictly validating answer keys and probability values.
Next action: Code suppresses repeated answers, then applies wake state and configurable gates for RESPOND/IGNORE. Invalid results become UNKNOWN under failure policy; default failure avoids unsolicited replies but permits explicitly woken requests.

Evidence limit: MIT AstrBot plugin reviewed without real chats or messages. Private-chat waiting/merging is local debounce, not Jev; sent streaming fragments cannot be recalled. Channel versions and gate effectiveness were not tested, and saving configuration cancels pending merged turns.

Original sources: GitHub Source Source Source

Image-judgment experiment gamePublic code

Human versus Jev: compare two independently judged images

Author / team: rocktane

Input: One real and one generated image per round, re-encoded to remove metadata. Jev and the player see identical pixels; source labels are withheld from the model.
Jev decision: Experimental image assets go through separate concurrent native System One Nouls asking whether each image was AI-generated.
Next action: Code selects the higher probability, abstains on exact ties and invents no choice on failure. It compares against declared truth, records five-round scores/timing and discards stale-round results.

Evidence limit: Root licensing is unknown; listed as a code case. No image corpus is included, and manifest validation proves neither provenance nor rights. Five pairs are not a general detector benchmark and scores do not establish image origin. No images, gameplay, cookies or paid calls.

Original sources: GitHub Source Source

Domain-QA input screeningPublic code

airportiq: scope and injection checks before the answer agent

Author / team: ozeriyarin

Input: Current text and the previous user question in an airport-capacity assistant, after local regex and fixed greeting paths.
Jev decision: Pinned Pydantic AI 2.63.0 TypeSafeModel sends typed in_scope and injection questions to Jev; the upstream adapter’s system_one call was checked.
Next action: Errors or provided confidence below the configured gate fall back to Haiku. Code returns fixed refusals or admits the answer agent; data tools and generation run separately.

Evidence limit: Unknown root licensing, listed only as a code prototype. Missing keys skip models and test mode is simulated; an empty confidence map does not trigger low-confidence fallback. No investment analysis or airport-data validation, and performance, budget or screening efficacy were not qualified.

Original sources: GitHub Source Source Source Pinned upstream adapter

Static-review advicePublic code

Code review: Jev advice is a report observation, not release authority

Author / team: groktopus

Input: A summary of review mode, coverage, required-scope count, finding IDs and routing reasons, without executing target code.
Jev decision: An optional native TypeSafe provider asks a Noul risk-advice question. A separate explicit Laya path supports three-class Choice, with model/type validation and distinct identity.
Next action: After forming the review result, remaining budget/deadline gates the call; advisory_assessment records RECEIVED/FAILED/NOT_RUN with usage and provenance. Advice grants neither approval nor publication authority.

Evidence limit: Experimental source review with unknown root licensing, so no project listing. Jev needs trusted opt-in configuration; private Laya or compatible services are not TypeSafe measurements. README discloses incomplete early reviews and preview-only publish. No target execution, model calls or third-party PR reviews.

Original sources: GitHub Source Source

Parallel-judgment visualizationPublic code

Decision Wall: 200 yes/no questions become a thresholded heatmap

Author / team: charles-forsyth

Input: User text and two hundred concrete questions from a selected set, bounded by backend text, question-count and question-length limits.
Jev decision: One native System One request asks Nouls over the same state; the proxy accepts yes/no questions only.
Next action: The frontend colors probabilities, filters threshold crossings and displays changes, recomputing locally when the gate moves. Questions and JSON export are available; cached and recorded answers are labeled separately.

Evidence limit: MIT community experiment; author latency tables are not site measurements. Static hosting may replay recorded answers rather than call live. Missing Nouls become zero in the frontend, not established negative answers. No demo interaction, keys, user text or model calls.

Original sources: GitHub Source Source

Static PR-review observationsPublic code

PR wall: separate runtime-change, test-reach and assertion judgments

Author / team: House Elves

Input: PR file lists, size-budgeted diffs and repository test-layout context. Path rules supply the test-file count rather than asking the model to infer it.
Jev decision: One native Jev batch asks a runtime-change Noul plus test-reach and outcome-assertion Choices, including insufficient-evidence options.
Next action: Local caches bind answers to PR commits and question/context/model fingerprints. The wall exposes probabilities, sorting and filtering; Right/Wrong feedback binds to the judged answer without a composite score or GitHub writes.

Evidence limit: Apache-2.0 Java tool. Static judgments establish neither measured coverage nor test execution. Oversized diffs are not arbitrarily truncated, and omitting --save previews only. Enabling sends diffs to Jev; no real PRs, credentials, reviews or Java execution were used here.

Original sources: GitHub Source Source Source

Coding-agent routingPublic code

Coding routing: separate policy applies model tier and reasoning effort

Author / team: guanghuang

Input: The current request, optional recent context, available model/effort choices and recent exact-model cache observations, with missing evidence marked unknown.
Jev decision: TypeSafe SDK systemOne batches task/reasoning/tool-complexity Scores, model/effort Choices and text-sensitivity Choices.
Next action: The proxy validates options and confidence, preventing low-confidence downgrades or capping upgrades. Effort must be supported by the chosen model before upstream model/effort fields and local observations are updated; failures retain the tier.

Evidence limit: MIT source, scoped to the Codex proxy path rather than qualifying every Claude/Pi host. Prefix preservation guarantees neither cache hits nor savings. Sensitivity is judged after text is sent in the same batch and only affects local logging. No launcher installation, subscription credentials or model calls.

Original sources: GitHub Source Source Source

Windows support prototypePublic code

Customer-service RPA: select fixed replies, then gate sending

Author / team: ChanghaoLiao

Input: Chat state transcribed by a separate vision model, the current category and an approved reply tree, under a serialized message-discovery workflow.
Jev decision: Native Jev Choices descend through categories/fixed replies with HUMAN at every level, then check applicability with SEND/HUMAN, validating options and distributions.
Next action: The model returns candidate library text only. Automatic sending additionally needs approved replies, onboarding/upload consent and local page-identity, draft, message-change and outcome checks; uncertainty routes to a human.

Evidence limit: MIT Windows/Clicknium prototype with historical Xianyu/Edge checks, not completed 1688 support. Legacy numeric settings remain but routing uses explicit Choice, not those gates. Offline demos are simulated and a visible bubble is not server delivery. No chat screenshots, drivers or messages here.

Original sources: GitHub Source Source Source

Latency/action simulation studyPublic code

Drone simulation: account for decision delay before discrete actions apply

Author / team: subho004

Input: Simulator observations, current action and optional mission information, with selectable decision providers and latency policies over the same scenarios.
Jev decision: A Jev Choice through OpenRouter alpha selects among eleven predefined actions such as forward, brake, hover, avoidance and landing; only exact action parses are accepted.
Next action: The harness schedules application at t+ceil(L/dt), retains the previous action while waiting and sends the selected action to an executor/PID. Invalid outputs initially retain the action and eventually hover, with trajectories/metrics recorded.

Evidence limit: The source is view-only with all rights reserved, so no open-source project listing. This is source reading and factual review without executing or redistributing code/data. Simulator, oracle, reflex shield and latency ablations remain distinct; author outcomes/costs are not reproduced results or real-aircraft safety evidence.

Original sources: GitHub Source Source Source

Commit and agent-behavior reviewPublic code

Commit hooks: local gates turn Jev judgments into blocks or warnings

Author / team: hierichhsu

Input: Locally masked, filtered and chunked Git diffs plus optional goal/architecture constraints, after deterministic checks.
Jev decision: Batched Nouls judge secret leakage and test weakening, with optional complexity Score. Providers include Cloudflare, OpenRouter and pinned native jev-1.13.0.
Next action: Code compares blocking signals with per-signal gates and returns nonzero from the commit hook; architecture/complexity warn only. Provider cooldowns and observations are retained, while model failure is fail-open.

Evidence limit: MIT community tool with author-derived gates/latency, not a no-leak or security-approval guarantee; masking/model judgments may miss cases. Pinned source only: no hooks, local diffs/credentials or dangerous commands. Other hosts and provider paths were not independently qualified.

Original sources: GitHub Source Source Source

Mail triage and reviewPublic code

Batch mail cleanup: Jev signals feed local policy and review

Author / team: Meerav29

Input: Email metadata, bounded body text, age and enabled folder descriptions.
Jev decision: One native TypeSafe JS SDK systemOne request uses a destination Choice and twelve Nouls for importance, reply needs, marketing, staleness and other signals.
Next action: Independent local policy selects auto-archive, proposed filing or review cards. Live batches can archive immediately; other moves await Apply, which rechecks each thread and inbox state to avoid repeated or stale changes.

Evidence limit: MIT community project reviewed at a pinned commit without Gmail or model access; fake mode does not prove live operation. Dry run prevents Gmail writes but still sends content to TypeSafe and optionally Anthropic. Claude writes card explanations; Jev does not generate them, and its signals do not guarantee safe archiving.

Original sources: GitHub Source Source Source Source

Message routing and context projectionPublic code

Slack multi-agent routing: separate response admission from exact-source selection

Author / team: u1-liquid

Input: The complete current message, root plus up to seven recent prior records, receiving bot and native authenticated candidates, within segment and byte limits.
Jev decision: Native /v1/systemone Choices judge response and conditional scope, plus optional prior references. Admission requires response=yes and native confidence strictly above 0.5; prior references separately require at least 0.8.
Next action: Project exact source text to the corresponding Hermes receiver. Unrepresentable mixed scopes stop projection; unselected ordinary input is silently acknowledged, while the host owns queues, history and authorization.

Evidence limit: MIT community plugin using private seams of a pinned Hermes revision. It has no inference elapsed-time cutoff, durable ownership or exactly-once guarantee. Conversations leave the machine; routing does not authorize external actions. No install, Slack connection, classifier-accuracy or delivery qualification was performed.

Original sources: GitHub Source Source Source

Literature screening and reviewPublic code

PDF study excerpts: bounded classification produces review flags

Author / team: bertran2born

Input: Selected method/result excerpts from a bounded number of PDF pages, with insufficient text marked for OCR or review.
Jev decision: Nine native /v1/systemone Choices cover field, primary finding, significance, preregistration and analytic-decision timing, with unknown/unclear options and validated complete probability distributions.
Next action: Write CSV rows with choices, confidence and all probabilities. Explicit post-hoc, uncorrected-testing or overclaim signals at least 0.8 add review flags; HTML supplies filtering, probability gates and export.

Evidence limit: Pinned public-source review only; no confirmed root license, so no license-verified project listing. Excerpts are partial and silence is not absence of a method. Flags do not establish misconduct, scientific truth or clinical suitability. No local PDFs, live model runs or independent outcome reproduction.

Original sources: GitHub Source Source

Suggested-next-step rankingPublic code

Next steps: rank with Jev, then fill a draft

Author / team: kevinyin9

Input: Up to three prompts generated by the session model; Jev receives at most 2,000 characters of the latest user message, 6,000 of the latest answer and the candidates.
Jev decision: Native /v1/systemone asks a five-level Score per candidate for progress toward the current goal; code maps 0–4 to 0–100.
Next action: Sort by score and mark a recommendation only when the best reaches 50. Number keys or Tab fill a draft; the user still edits and presses Enter. Missing keys, a three-second wait timeout or invalid answers retain unscored original order.

Evidence limit: MIT community plugin using an early terminal Claude Code API, excluding desktop/VS Code. Conversation text, potentially including sensitive code/data, leaves the machine and there is no per-session egress switch. Scores do not optimize long-term goals; Promise.race timeout does not prove HTTP cancellation. Pinned-source/author-synthetic-example review only, without install, local transcripts or independent outcome testing.

Original sources: GitHub Source

Clipboard-command reviewPublic code

Clipboard commands: hold first, then block or restore by Noul probability

Author / team: Ryankapa

Input: Bounded Windows clipboard text recognized as command-like by local patterns, excluding supported private clipboard formats.
Jev decision: One native /v1/systemone ClickFix Noul; the yes probability is multiplied by 100 and rounded into a local risk number, not a Score primitive.
Next action: Hold text off the clipboard before judging. At the gate, retain the block and offer review; below it, restore only if the clipboard sequence is unchanged. An independent API-error setting chooses holding or restoration, and the user can explicitly release text.

Evidence limit: MIT Windows community prototype whose default 70 is an author starting point, without independent false-positive/negative calibration. Command-like content can contain sensitive data sent externally; the prefilter is neither a privacy nor safety guarantee, and holding/judging has race boundaries. No EXE, local clipboard, commands or SmartScreen bypass was used; the demo is an author Windows Sandbox sample.

Original sources: GitHub Source Source Source

Real-time message moderationPublic code

Chat moderation: local policy blocks sends or edits after Noul judgments

Author / team: ravex-io

Input: Message text being sent or edited, after local type, control-character and length checks, enabled only with explicit moderation configuration.
Jev decision: Pinned jev-1.14.0 through native /v1/systemone asks an abuse Noul and default-enabled injection Noul, validating a finite in-range answer per question.
Next action: Default abuse/injection gates are 0.7/0.9; crossing one throws MESSAGE_BLOCKED and invokes the flag callback. Handlers screen before broadcast or edit writes, then recheck queue/shutdown state. Transient retries and circuit pauses are separate from content judgments.

Evidence limit: MIT community integration with original-author X and pinned-source review, without chat or model access. Default fail-open can deliver unscreened messages; explicit closed blocks. Provider input refusal is rejected in either mode. Fake-Jev tests do not prove accuracy, injection protection or live delivery; this is not end-to-end encrypted chat.

Original sources: Author X GitHub Source Source Source

Host model-configuration policyPublic code

DSH routing: keep the main model while judging depth and child capability separately

Author / team: prgrmrwy

Input: Current task, bounded prior user/assistant text, main-model and explicit child selections, plus the host catalog, allowlist and effort cap.
Jev decision: Native TypeSafe or OpenRouter alpha asks a depth Choice (lower/baseline/higher). Children may add a capability Choice (bounded/analytical/frontier/insufficient_context), preserving explicitly selected dimensions.
Next action: Keep the main model and move at most one supported effort step in a registered family, synchronized through selectModel. Bind initial child allocations within catalog/allowlist/cap gates; failures, mode changes, missing context or unsupported paths retain native configuration or record fallback.

Evidence limit: MIT community plugin with author acceptance scoped to a DSH revision and Web UI, not all live teammates, forks or third-party entry points. selectModel also saves host global defaults; AUTO judgments send text externally, and local feedback does not yet train automatically. Pinned-source review only, without install, local configuration changes or author cost/quality reproduction.

Original sources: GitHub Source Source Source Source

Voice intent and lookup routingPublic code

Voice sports lookup: map transcripts to bounded teams and data views

Author / team: WyattKnepp

Input: Local Whisper transcript or typed text, with predefined teams, views and optional rosters.
Jev decision: One native Python SDK call batches a request Noul and team, opponent and view Choices. Player views may ask another roster Choice, with weak matches falling back to name search.
Next action: After the request gate or explicit force, query cached ESPN views using selected parameters and deliver results over SSE; the interface can exclude mistaken teams and rejudge.

Evidence limit: Pinned public-source review with no confirmed root license, so no license-verified project listing. Opponent logic bypasses none and may select a real team above the author 0.15 gate; mistakes and stale cached data remain possible. Latency is author-reported. No microphone, model download, server or sports-freshness qualification.

Original sources: GitHub Source Source Source

Table semantics and visualizationPublic code

Table shading: Jev judges comparability and direction; code computes colors

Author / team: philrenaud

Input: Tables near the viewport on enabled sites: page/table titles, headers, bounded samples and categorical labels, plus leading/trailing aggregate-row evidence.
Jev decision: Jev Nouls and Choices judge comparability, better-value direction, logarithmic relationships, category ordering and aggregate rows. The native own-key transport was reviewed, alongside selectable author-hosted and Clef paths.
Next action: Local gates choose shaded columns, neutral/directional palettes and aggregate exclusions. Ordinary code handles parsing, range midpoints, proportions, sorting and DOM colors; one failed table does not erase successful ones.

Evidence limit: MIT community extension not installed, used on private tables or reconciled with the store build. Table text leaves the browser; free mode uses the author Worker, whose storage/counting policy is author-described rather than audited here. Semantics/gates can err, colors are not investment/product recommendations, and recorded evaluations do not establish arbitrary-page performance.

Original sources: GitHub Source Source Source Source X discovery

Official search demoPublic code

Official sheet demo: grouped Choice shortlisting followed by batched Scores

Author / team: TypeSafe AI

Input: A natural-language stay request and 1,000 sampled Cape Town listings in Google Sheets, including price, capacity, descriptions and links.
Jev decision: Ten parallel Choices rank groups of 100 listing IDs, taking five per group by probability. One further state contains the 50 shortlisted descriptions with a five-level Score per listing.
Next action: Apps Script maps 0–4 Scores to 0–10, returning the top ten with original fields. Cache hits return directly; a full first run on the 1,000-listing sample uses eleven requests.

Evidence limit: The official page includes Apps Script, but no sheet, key or API execution was performed here. About-one-second timing is official-reported; grouped pruning can miss globally better candidates. Descriptions are bounded to 300/1,500 characters, and the six-hour cache key excludes price/description content, so edits with unchanged links can reuse stale results. The page attributes a 2026-09-23 Inside Airbnb sample under CC BY 4.0; match scores do not verify current bookability or property facts.

Original sources: Official demo and Apps Script

Code review triagePublic code

Session review: separate scope, API constraints and test evidence

Author / team: elizabethsiegle

Input: A reviewed local request, an Entire-exported Codex session and a matching diff; JSONL filtering retains conversation/tool evidence and excludes system/developer messages.
Jev decision: A native system_one call asks three Nouls: scope drift, violation of the public-API constraint, and a completed test command with a successful result. An unsupported claim that tests passed is excluded.
Next action: Risk ≥0.3 or test evidence <0.9 selects focused_review with review flags; otherwise standard_review. Missing context or provider errors exit; the script does not merge changes.

Evidence limit: Community triage prototype whose thresholds need labeled-session calibration; probabilities do not prove correctness. No Entire/API run or private session access here. Saved comparison probabilities predate privacy edits to the public sample, so they do not establish reproduction on current bytes. Root license unconfirmed; code case only.

Original sources: GitHub Source Evidence and sample caveats

Tool semantics and approval policyPublic code

Tool catalog review: Choice classes inform host approval holds

Author / team: omniaura

Input: Catalog tool names, descriptions, argument schemas and provider-declared labels. Reviews bind to the tool/input fingerprint, not each actual call or user intent.
Jev decision: OpenRouter alpha/decisions requests typesafe/jev-1.13 with a Choice over read, write, outbound and destructive.
Next action: Outbound+destructive probability ≥0.5 adopts an approval class; Effective takes the stricter of provider and review labels. The host must enforce RequiresApproval. Memory, storage and compiled manifests serve catalog results while queued reviews run off the request path.

Evidence limit: MIT community library; no live tools or model execution here. Per-tool review is not per-call authorization: missing/failed reviews can fall back to provider labels, and stale verdicts may still be served with a flag. This is not a fail-closed permission layer. The 0.8 read/write thresholds affect labels, not the 0.5 hold gate; author latency/cost figures were not reproduced.

Original sources: GitHub Source Source Source Source

Browser actions and task judgmentsPublic code

Tern browser loop: bounded DOM actions with a separate goal probability

Author / team: CyriusWeng

Input: Task, current URL/text, visible elements/fields, recent actions/pages and mechanically checked scroll geometry and facts.
Jev decision: One native /v1/systemone request asks operation and per-operation target Choices plus goal/stuck Nouls for completion and repetition. The pinned code requests jev-1.14.0.
Next action: Code validates Choice labels/probabilities before clicks, fills, selections or scrolling; a separate chat model generates field text. A goal ≥0.9 or arrival/DONE heuristics can stop execution; repeated targets, blocks and budget limits also terminate with step evidence and final URL.

Evidence limit: MIT community derivative retaining browser-use/jev-ultrafast notices. Only the DOM path was statically reviewed; no Tern install, key access, browser-task run or reproduction of the author’s 18–73× claim. Box/canvas is preview wiring with unverified compatibility. DONE heuristics include a missing-goal fallback and do not independently prove success; external writes still require host authorization.

Original sources: GitHub Source License and inherited notices Author post

The public awesome-jev-cases repository holds the data, original links, and automatic inclusion rules.

Official cookbooks

This directory is checked daily against TypeSafe’s official docs index and each linked page. Summaries are based on the official index and cookbook pages; measurements in those guides have not been reproduced by this site.

25 official cookbooks verified; summaries are based on the official index and cookbook pages.

Self-consistency: nouls — Route uncertain probabilities to human review while keeping the underlying noul values visible.
Self-consistency: choices — Add an uncertain outcome to moderation decisions and compare label agreement with the share of automatic actions.
Parallel questions — Runs a 13-question regulatory briefing over the GDPR Wikipedia article, showing that batching every question into one TypeSafe call is 12.2x cheaper and 10.0x faster with no change in answers.
Re-ranking — Builds 30-passage BM25 shortlists for 40 CLERC legal queries, then uses one TypeSafe question per query-candidate pair to raise top-1 accuracy from 5% to 18% and top-10 accuracy from 38% to 62%.
Line-by-line search — Build semantic search for GitHub's Terms of Service. In one request, score 218 line ids against a plain-language query with a Choice question, and use a Noul question to check whether the document contains an answer.
Structure recovery — Reconstructs Markdown from plain text that lost its formatting in two requests: one stitches hard-wrapped lines back together, one classifies every block (heading, list, code, callout).
Function calling — Maps natural-language requests to typed function names and bounded arguments. The current example memoizes state/questions without the model in its cache key and fills the response model from the requested value, so replayed answers do not prove a new model was called.
Skill suggestion — Picks at most one skill for an agent turn out of the 182 in Nous Research's Hermes catalog, using two TypeSafe requests to rank and re-check the top candidates.
Knowledge graph entity alignment — Routes 450 Wikidata/MusicBrainz album pairs to no link, curator review or a merge recommendation using a three-level Score; three Nouls expose title, artist and label agreement. CC0 dataset links are imperfect reference labels, not verified truth; this is not an automatic knowledge-graph merge.
Classifying RAG passages — Score each retrieved passage with one TypeSafe request, then decide in code which ones reach the answering model.
Double-checking citations — Catch wrong or hallucinated citations by checking against the source document. One Choice question decides whether the quote's context supports the claim.
Guardrails for LLMs — Screen every message going into and out of an LLM app with one TypeSafe request, thresholding hazard probabilities and severity to pass, review, block, or route.
SDE cascade — Uses a 2-stage structured-data-extraction cascade (mini → verify → reasoning) to get most of the quality of a big reasoning model at a fraction of the cost.
Date extraction — Extracts absolute and relative dates by asking TypeSafe for the parts named in a document, then resolving and validating them in code with confidence-based review.
Pre-parsed value extraction — Uses regexes to find candidate emails, phone numbers, and amounts, then has TypeSafe select the requested span so code can normalize a verbatim value.
Hierarchical classification — Uses parallel beam search over Choice probabilities for pinned CPC 2026.05, Shopify 2026-02 and January-2026 MeSH hierarchies. Taxonomy data retain publisher terms; three author-worked examples are not a general benchmark, and biomedical subject classification is not medical advice.
Autoresearch feature discovery — Runs an autoresearch loop that proposes TypeSafe questions, converts free text into numeric features, and uses model errors to improve a supervised CatBoost regressor.
Classification using confidence — Classify SEC annual reports into 75 industry groups with one Choice each, then read the answer's own confidence to decide whether to report that group or the broader division above it.
Simple memory system — Store customer tickets and answers behind a Noul memory gate, then inject them into later typed support-routing calls. Toy dict-based example; evaluate the threshold for your own data.
Twitch chat filter — Classify one stream-chat message with a Choice and toxic/spoiler Nouls; code hides, blurs or highlights it. Authored 29-message English example; adapt thresholds, uncertainty and live-message handling locally.
Intelliprompter — Score pending presentation criteria against the accumulated transcript, then keep criteria checked after a local coverage gate. Six authored chunks demonstrate the one-way checklist; microphone/transcription integration is outside the cookbook.
Reading a scanned vaccination record — Find candidate vaccine rows with Nouls and Boxes, read years with a Choice including unreadable, then flag/crop rows for human review. Official experimental image workflow, not clinical or travel-health guidance; published results are not independently reproduced.
OCR confidence and bounding boxes — Check already-extracted invoice values against a full photo and a zoomed Box crop using Nouls; either check below 0.25 flags human review. Experimental images/Box and official cached examples, not independent OCR or production validation.
Feeder-cam visit log — Apply Noul, Choice and Box questions to one video frame per second, then merge detections into species visits in code. Experimental image workflow limited to two different species; occlusion and same-species birds remain limitations. Reported 101-frame results are official claims.
Shopping cart — Find menu items with a shrinking-options Choice loop and a nothing_else sentinel, then batch known field Choices per item. Code assembles the cart; each item appears once and quantities are not modeled. Published outputs are official reports, not site measurements.

Four patterns drawn from the cases

The official use-case map lists candidate scenarios by industry, all sharing one structure: embed AI decisions into the software workflow while code keeps control. We picked four patterns with clear shape and community traction and wrote them up:

Scenario	Types used	Pattern in one line	Walkthrough
Model/intent routing	Choice + confidence	Confident → cheap path; unsure → strong model or human	Model routing
Content moderation	Score	Rate by risk level; publish/review/remove in code	Content classification
Tool approval	Noul + Score	Risk-check every tool call: deny / ask / allow	Tool approval
Ticket triage	All three	One request: classify, gauge urgency, detect refunds	Ticket triage

Why these four

They share the profile of work Jev is good at (our framing):

High frequency: thousands of judgments a day, sensitive to latency and unit price
Narrow judgment: one question, a closed answer set (options/levels/yes-no)
Probabilities over prose: the consumer is a code branch, not a human reader
Reviewable: confidence and logs retained; edge cases can go to humans

Official patterns worth knowing

From the official Patterns docs (via the llms.txt index):

Speculative fan-out: send a batch of “maybe relevant” questions in one request and let code pick answers — no round trips for branchy judgment trees
Composite scoring: split a complex judgment into atomic Scores; merge with your own weights in code
Intent routing: classify first, then dispatch to deterministic logic / a specialist model / a human

The community has open-source implementations (router plugins, MCP servers, safety gates) — see Ecosystem. For measured claims (LangChain’s 500-eval study, Vercel numbers relayed by TechCrunch), check the verification table in Limitations before quoting any figure.

Three questions before adopting

Can this judgment’s answers be enumerated as options/levels/yes-no? If not, Jev doesn’t fit
What does a wrong judgment cost, and is there a human-review fallback? If not, be careful with automation
Is your current approach pure rules or a big model doing everything? The former may not need a model; the latter may only need Jev up front

For code you can run today, start with Ticket triage — it ships with site examples (JS / Python).

Jev Model Guide (typesafe-jev.com) is an independent community site with no affiliation with, endorsement by, or agency for TypeSafe AI. Opinions here are the editors’ own. See Privacy & ad preferences. Jev, System One, and TypeSafe are names belonging to their respective owner.

Official entry points: typesafe.ai·docs.typesafe.ai·console.typesafe.ai