Explore real projects using Jev for moderation, automation, model routing, and semantic search. Each entry explains what Jev decides, how the decision fits into software, and what you can learn from the implementation.
74 projects · Last reviewed: September 18, 2026
Browse cases · What is Jev? · Integration guide · Suggest a case
Jev is TypeSafe AI’s System One model for structured judgments: choices, scores, and probabilities that application code uses to select the next action.
An independent community collection curated by SeeAPI, not an official TypeSafe project. See review scope.
| Category | Projects | Explore |
|---|---|---|
| Content moderation & safety | 7 | Content screening, risk judgments, and moderation actions |
| Automation & integrations | 15 | Desktop, browser, mobile, and workflow integrations |
| Model routing & code workflows | 12 | Model selection, code review, and agent assignment |
| Semantic search & graph navigation | 5 | Graph navigation, semantic search, and reranking |
| Data classification & productivity | 13 | Spreadsheets, document analysis, and ticket classification |
| Experiments & specialized applications | 13 | Games, control systems, and specialized applications |
| Benchmarks & behavior studies | 9 | Author-reported evaluations and model behavior studies |
Repository · Vision implementation · Jev judgments
An HTTP gate that checks prompt injections, unsafe images, and unsafe replies before optionally forwarding a request. Its image pipeline first uses gemini-3-flash to describe the image, then asks Jev to judge risks in that description.
Pattern: detection and interpretation → typed risk judgments → allow, review, or block.
Scope: this is a vision-model-plus-Jev pipeline, not evidence of native image classification by Jev. The current project is a safety gate; earlier descriptions of it as a model router are outdated. We have not measured its detection accuracy.
A Discord moderation bot that evaluates messages and context for phishing, spam, and social engineering. Code applies escalating actions, and moderator corrections become safe precedents in later judgment context.
Pattern: contextual message classification → moderation action → feedback.
Scope: a text-message moderation project, not an image or video NSFW benchmark. False-positive performance has not been independently verified here.
Email classification experiments comparing natural-language Jev decision criteria with TF-IDF classifiers and combined scores, including tests across different mail sources and time periods.
Pattern: written classification criteria → probability → threshold or ensemble.
Scope: exploratory author-reported experiments. The criteria were refined after inspecting labeled errors, so “no task-specific training” should not be confused with “no supervision.” We have not reproduced the results.
Exposes jev_verify, jev_screen, and jev_find to agents for evidence-based claim checking, input screening, and semantic candidate ranking.
Pattern: package narrow judgments as reusable agent tools.
Scope: verification depends on the supplied evidence; individual successful examples do not establish general accuracy.
Source · Implementation / documentation
A capability broker optionally uses Jev to flag suspicious MCP tool output and show risk advice at a human-approval prompt. Deterministic capability checks and the human approval decision remain separate from the model advice.
Pattern: Capability enforcement → optional content warning or risk advice → human decision where required.
Scope: The Jev layer is advisory and does not make the broker’s permission decision. The author’s attack demos use a fake upstream and test credentials. Missing warnings do not establish safety, and permitted operations can still be misused. Not executed here.
Reviewed: 2026-09-18.
Source · Implementation / documentation
The author describes a chat application using Jev, Convex, and Vercel to review messages before display. Natural-language room rules can be edited to trigger re-evaluation, with uncertain messages held for human review.
Pattern: Message and room rules → moderation judgment → display or human-review queue.
Scope: This entry is based on the author’s public description, not a verified backend implementation. No messages were submitted or rules saved during this review; thresholds and moderation accuracy remain unverified.
Reviewed: 2026-09-18.
The author presents a Chrome extension that uses Jev to flag potentially malicious addresses and transactions on Etherscan. The collection records it as an author-demonstrated risk-indicator interface.
Pattern: Blockchain-explorer context → risk judgment → on-page indicator for human inspection.
Scope: The author’s post establishes the claimed integration, not its accuracy. Public implementation, input features, thresholds, and request traces were not verified. A risk label is not proof of fraud, and no extension or model call was run here.
Reviewed: 2026-09-18.
Repository and measurement notes
A browser agent that turns visible controls into indexed candidates. Jev chooses an operation and target; a separate language model writes text when needed.
Pattern: observed state → bounded action selection → execution → observation.
Scope: the reported roughly 7.1-second flight search is a specific author-measured run, timed after the initial page observation. It is not a general browser-task speed guarantee.
Demo material: Original flight-search demo
Original author material: Flight-search result. Measurements shown are author-reported, not SeeAPI tests. MIT · Source · License and attribution
A Jev integration reads an operating-system accessibility tree, selects an operation and target, and hands the result to a local desktop executor.
Pattern: separate interface observation, model decisions, and execution.
Scope: agent-desktop is a broader desktop tool with a specific Jev integration, not an exclusively Jev-based project.
Demo material: Original desktop demonstration
An MCP server connecting Claude Code, Claude Desktop, and Codex to Jev. Its evaluate tool accepts state and Noul, Choice, or Score questions for tasks such as ticket triage.
Pattern: ask several independent typed questions about the same state.
Scope: an integration tool; configurable examples should not all be counted as deployed customer use cases.
Brings semantic predicates, routing, scoring, filtering, and guard decisions into Unix pipelines and CI through is, choose, score, filter, and guard commands.
Pattern: typed judgments with explicit thresholds, uncertainty, and process exit codes.
Scope: semantic judgments do not replace authorization or execution controls.
A Mac automation loop converts screen information through OCR and deterministic processing, asks Jev to choose an action, and uses a writing model only when free text is needed.
Pattern: Screen interpretation → bounded action selection → desktop execution.
Scope: OCR and local processing provide perception; Jev does not directly inspect screenshots. Author timing comparisons include task-specific preprocessing and have not been reproduced here.
An agent skill and runtime that uses existing browser tools in a continuous observation, action, and verification loop. The planning agent supplies the goal and navigation guidance; Jev selects observed elements.
Pattern: Plan once, then execute repeated bounded browser decisions.
Scope: An unofficial integration requiring compatible browser tools; it is distinct from browser-use/jev-ultrafast and is not a browser service by itself.
Demo material: Original browser demo
A mobile agent uses Jev to select actions on a real Android device through Mobilerun, with a studio, CLI, and execution traces.
Pattern: Goal → mobile state → action selection → device execution.
Scope: The documented Uber demo reaches payment selection, not a completed booking. The reported 21 seconds for nine actions is one recorded task, not a general latency guarantee.
Demo material: Android demo: Uber route to payment selection
Original author material: Android Uber demonstration. Measurements shown are author-reported, not SeeAPI tests. MIT · Source · License and attribution
Adds Jev semantic checks to Zod schemas, turning probabilities into validation issues alongside ordinary shape checks.
Scope: Uncertain and unavailable judgments need explicit handling; a passing check does not establish factual correctness.
Turns home entity states into Jev probabilities, choices and scores exposed as sensors or automation responses.
Scope: Device-state quality and automation policies determine whether a judgment is useful; integration was not run here.
Exposes typed TypeSafe questions inside n8n so downstream workflow nodes can branch on answers.
Scope: A community integration; installation eligibility and retry handling depend on the n8n environment and workflow.
A browser extension classifies page elements with Jev and hides selected clutter using reusable rules.
Scope: Uncertain elements should remain; hiding a consent dialog does not make a consent choice for the user.
Uses semantic UI state, stability checks and bounded action choices for an Android observe–decide–act loop.
Scope: The author exercised Android Settings; this is distinct from droidrun/mobile-jev and is not a general mobile agent.
Source · Implementation / documentation
A Python worked example shares a judgment engine across support tickets, operational alerts, and deployment risk. Batched Noul risk signals and a severity Score feed code-owned policy tables; the ticket flow adds department and urgency judgments.
Pattern: Input → risk battery → policy thresholds → pass, review, block, or support route.
Scope: The author labels it R&D. Its keyword-based offline mock tests composition rather than Jev quality; mock results must not be presented as model results. Thresholds and real deployment outcomes were not validated here.
Reviewed: 2026-09-18.
Source · Implementation / documentation
An asynchronous LangGraph example sends email sender, subject, and body to a Choice question for invoice or general intent. Handlers set accounts_payable or general_inbox in graph state.
Pattern: Mock email → Jev intent classification → graph branch and destination label.
Scope: Handlers do not send email or make payments. Ten labeled mock emails are a smoke check, not an accuracy benchmark. The graph records confidence but has no low-confidence routing threshold; this collection did not execute it.
Reviewed: 2026-09-18.
Source · Implementation / documentation
A Pi extension combines deterministic command rules with Jev judgments before bash, write, and edit calls. Code compares condition probabilities with thresholds to produce allow, deny, or uncertain decisions.
Pattern: Tool call → deterministic checks → semantic conditions → local execution gate.
Scope: At review, README describes blocking uncertain results, while src/settings.ts sets uncertain to allow; src/jev/decide.ts treats an uncertain hazard-mode condition as satisfied. Check the actual version and policy rather than assuming fail-closed behavior. No safety guarantee or runtime validation is established here.
Reviewed: 2026-09-18.
Classifies coding turns with Jev and applies a policy to select a model and reasoning depth, with logging and fallback behavior.
Pattern: task classification → model selection → quality and cost evaluation.
Scope: the reported roughly 60% savings comes from the author's replay of 237 real turns. It is not a SeeAPI measurement or a guaranteed saving.
Judges blocks of long Claude Code tool outputs for task relevance. Confidently irrelevant blocks become summaries or stubs, while full text remains recoverable; uncertain blocks are retained.
Pattern: reversible relevance filtering before context ingestion.
Scope: judgment and summary generation are separate stages. Results using an alternative judge adapter should not be attributed to Jev.
Reviews diffs or codebases through staged judgments about risk, file profiles, evidence, mechanisms, severity, and conditional reviewer routing.
Pattern: compose small judgments to focus deeper review on concrete regions.
Scope: an experiment that currently does not integrate compiler diagnostics or static analyzers. Findings are review leads, not proof of defects.
Original material: Dev Agrawal · MIT · Unmodified · Source · License and attribution
Routes fresh user turns in Claude Code and Codex to fast or strong model tiers while launching the original CLIs.
Pattern: Classify a turn and select a model without replacing the CLI.
Scope: A separate project from Jev Codex Router by 0xNatoshi. Its README describes per-user-turn routing, not a fresh model choice for every internal tool step.
Original author material: Model selection interface. Measurements shown are author-reported, not SeeAPI tests. MIT · Source · License and attribution
Project · Discovery post · Implementation / 文档
The agent framework uses Jev by default for automatic model selection and typed evaluations; its documented tool-approval integration can escalate uncertain or failed reviews to a human.
Pattern: Embed typed evaluation in model routing, tools, and approval decisions.
Scope: Jev is the evaluator, not the sole model powering eve. The underlying AI SDK evaluation specification is experimental.
A proof-of-concept decorator routes boolean, enum and configured score fields to Jev while a generative model handles free text.
Scope: The author's comparison uses three examples; it does not establish general cost or speed improvements.
Demo material: Author three-example comparison chart
Scores diagnostic value and priority of OpenTelemetry logs before expensive analysis, while retaining an archive.
Scope: Annotation alone does not skip downstream analysis; savings depend on forwarding mode and policy.
Selects a specialist agent and judges ambiguity or the need for collaboration using typed questions.
Scope: Routing recommendations do not demonstrate an executed multi-agent workflow; keyless demo responses are local heuristics.
Provides typed commands for guard checks, build-log triage, diff review and bulk filtering, with reusable question recipes.
Scope: The author's agent experiment reduced file reads without reducing cost; judgments do not replace source inspection or a complete safety boundary.
Source · Implementation / documentation
A Pi extension checks edits against project rules and places feedback in the agent’s context. Other guards assess task drift, unsupported completion claims, and risky actions; deterministic patterns and model judgments feed code-owned responses.
Pattern: Agent context and proposed changes → rule/risk checks → feedback or selected holds.
Scope: Many findings steer or warn rather than block. The author’s 150 paired runs report fewer rule violations, but other measured axes showed little or no improvement; results are not independently reproduced. The extension is not a sandbox or complete permission boundary.
Reviewed: 2026-09-18.
Source · Implementation / documentation
A Rust CLI asks Noul questions about Git changes to identify bug-fix, security-fix, change-type, and CWE signals. Large inputs are reviewed in sections before selected evidence is used for a final judgment; local thresholds assign labels.
Pattern: Commit diff → section judgments → selected evidence review → thresholded labels.
Scope: Labels are model signals, not confirmed vulnerabilities. File policies exclude some content, and final reviews of long diffs use selected evidence rather than all changes. Source diffs and metadata are sent to TypeSafe; incomplete scans retain completed results. No scans were executed here.
Reviewed: 2026-09-18.
Source · Implementation / documentation
An experimental runtime sends bounded task, worker-output, diff, and verification observations to nine Noul questions in one request. A deterministic policy uses those assessments to continue, start, stop, retry, verify, finish, or escalate managed work; assessments are printed for the CLI user.
Pattern: Bounded worker observations → semantic assessment → local policy → process lifecycle action.
Scope: At the linked commit, the worker interface exposes run and terminate, not a text-steering channel into a running agent. Scores are uncalibrated for this use case; incorrect judgments can stop useful work or accept bad work. Static inspection only: no Foreman, Codex, or Jev execution was performed.
Reviewed: 2026-09-18.
Finds files from natural-language queries by having Jev score file and folder names, allocating walkers along likely paths.
Pattern: narrow a search space through repeated semantic choices.
Scope: result percentages represent the share of walkers reaching a file, not file correctness probabilities. This is not a full source-code semantic index.
Navigates a Neo4j graph by presenting outgoing relationships as Choice options, asking a Noul goal-completion question, and exploring candidate paths with beam search.
Pattern: model-guided edge selection inside a deterministic search algorithm.
Scope: a demo with explicitly labeled stand-in answers when real TypeSafe calls fail. A running demo alone does not prove that every answer came from Jev.
A Chrome extension asks Jev about relevance, promotional content and depth, then reranks Google results in code.
Scope: Judgments use result snippets rather than full pages; search intent affects filtering.
Parses source into functions and asks Jev a yes/no question for each, returning ranked matches with cached scores.
Scope: Function-local judgments do not establish whole-program dataflow; scanned source is sent to TypeSafe.
Source · Implementation / documentation
A TypeScript application asks Jev to select search sources, time ranges, and query candidates, fetches results through Search1API, then judges title/snippet relevance in batches. Code merges URLs and ranks results by relevance, engine agreement, and original position.
Pattern: Search intent → external retrieval → per-result judgments → merged, streamed rankings.
Scope: Relevance scores do not verify page facts; snippets can be incomplete or stale. A search can make several provider calls. Source and ranking code were inspected, but retrieval quality, latency, and cost were not measured.
Reviewed: 2026-09-18.
Typing a column header such as Urgency lets Jev infer a prediction schema; confirming it fills rows through JUDGE, PICK, and RATE functions, with grouped requests and streamed updates.
Pattern: Header intent → typed schema → row judgments → spreadsheet recalculation.
Scope: A standalone spreadsheet demo, not a Google Sheets integration. Roughly 100 ms refers to individual judgments or header interpretation, not the entire column. Timings are author-reported; mock mode is also available.
Demo material: Original screenshot and animated demo
Project · Discovery post · Implementation / 文档
The codebase includes a Jev evaluation client through Vercel AI Gateway, a NOTRA_JEV_CLASSIFIERS flag, and optional typed evaluation alongside brand-mention analysis.
Pattern: Introduce typed judgments into an existing analytics workflow with an LLM fallback.
Scope: Source inspection establishes an integration path, not independently verified production deployment or latency. Existing LLM judgment still supplies competitor information and excerpts in the inspected workflow.
Combines local text analysis with Jev questions about clarity, intent and tone; deterministic rules render diagnostics.
Scope: Diagnostics reflect chosen rubrics and thresholds, not objective writing quality or generated explanations.
Jev scores a product idea against several criteria; local weighting maps the results to a product verdict.
Scope: Heuristic feedback, not validated prediction of business success; the project also supports mock data.
Stores typed CV judgments separately from local scoring rules, allowing supported policy changes to reuse existing answers.
Scope: New questions require new judgments. The example policy includes age and military-service criteria; it is not an endorsed hiring policy or validated fairness assessment.
Labels Bluesky posts and drafts using Jev choices, with custom classifiers and filtering controls.
Scope: Text-only analysis excludes images, videos and wider conversation context; sarcasm can be misclassified.
Original author material: Tone labels and post filtering. Measurements shown are author-reported, not SeeAPI tests. MIT · Source · License and attribution
Demo material: Animated demo
Reviews extracted CV text against explicit rubrics and optional job requirements, showing questions and answer distributions.
Scope: Missing, inapplicable and unassessable evidence remain distinct; it does not provide a validated hiring prediction or ATS score.
Uses Choice for team assignment, Score for priority, and Noul for refund intent, churn signals and human escalation.
Scope: Without an API key the implementation uses local heuristic demo responses; those are not Jev results.
Batches sentiment, topic, bug and churn judgments over app reviews, then allows local reranking; includes a comparison with Gemini.
Scope: The published timing is from a recorded run pair. Agreement between models or with star ratings is not ground-truth accuracy.
Original author material: Author-recorded comparison. Measurements shown are author-reported, not SeeAPI tests. MIT · Source · License and attribution
Source · Implementation / documentation
A .NET and React application classifies Persian or English support tickets. One request asks Choice questions for category and team, a Score for priority, and Noul questions for sensitive data and human review; local rules handle escalation and redaction.
Pattern: Ticket → five typed judgments → local review and redaction rules.
Scope: The no-key demo can use deterministic mock answers. Low confidence forces human review rather than correcting category, team, or priority. Routing accuracy and redaction coverage were not tested.
Reviewed: 2026-09-18.
Source · Implementation / documentation
A proof of concept replays fictional support-call transcripts incrementally. Each enabled criterion contributes a Score and a Choice selecting an evidence sentence; code normalizes and weights the results, then stores the final evaluation in SQLite.
Pattern: Growing transcript → criterion scores and evidence selection → weighted score history.
Scope: This is transcript replay, not verified live audio recognition. Evaluations send the current transcript prefix to TypeSafe; costs can grow with the conversation. The documented local demo has no authentication. Scoring quality and timing were not reproduced.
Reviewed: 2026-09-18.
Source · Implementation / documentation
A manuscript-review tool pairs citing sentences with source passages. Claude can locate quotations, code checks quotation presence, and Jev chooses supports, contradicts, or says_nothing for the sentence and selected passage; the reviewer retains the final decision.
Pattern: Citation matching → passage selection → three-way support judgment → human review.
Scope: Jev reads a bounded passage around a quotation, or the source opening, rather than the entire paper. Passage-selection errors and abstract-only access limit the evidence. The author says thresholds lack biomedical validation; no manuscripts or model calls were tested here.
Reviewed: 2026-09-18.
Source · Implementation / documentation
A demonstration uses company profiles and headlines from yfinance in a staged Jev pipeline for relevance filtering, ranking, and mechanism matching. A request view exposes the state and typed questions behind the displayed judgments.
Pattern: Company/news inputs → staged judgments → code-based filtering and traceable results.
Scope: The author describes thresholds as initial guesses rather than values fitted to outcomes. Request visibility is not evidence of forecast accuracy or investment returns. No trading effectiveness, reported cost, or timing was independently tested.
Reviewed: 2026-09-18.
A Rust CLI exploring tasks such as protected health information detection and code-comment review through typed questions and scores.
Pattern: reuse decision primitives across clearly defined application criteria.
Scope: experimental tooling, not a privacy-compliance certification. Rubric scores and confidence probabilities should not be conflated.
Maps liquidity-strategy questions about distribution choice, toxic flow, recovery holding, and market stress to Choice and Noul judgments alongside existing heuristics.
Pattern: compare model advice with existing rules in shadow or advisory mode.
Scope: the inspected Jev module explicitly states shadow/advisory use. It is not evidence of profitable autonomous trading by Jev.
A browser FPS opponent controlled through Choice/Noul questions about movement, aim, ADS, firing, and jumping. The server supplies structured game state and includes a heuristic fallback.
Pattern: repeated bounded decisions drive a real-time interactive agent.
Scope: the README's approximately 9 Hz loop describes this project, not a universal Jev performance figure. The agent is not shown to operate from raw visual input alone.
A trading experiment asks Jev for buy/sell judgments from the Kuru MON-USDC order book on Monad, with code handling quotes, limits, and execution.
Pattern: Order-book state → directional judgment → program-controlled order handling.
Scope: The default model is a mock momentum heuristic; Jev requires explicit configuration. Without a private key the app dry-runs, and the linked deployment is documented as dry-run/mock. No profitability claim is established.
An emulator harness converts telemetry and RAM into structured state; Jev selects NES controller actions and provides jump and danger judgments.
Pattern: Structured game state → Choice/Noul/Score → controller input.
Scope: The model does not receive screenshots. This is an experimental controller, not evidence of general visual game-playing ability.
A MuJoCo quadrotor simulation converts camera depth and segmentation into symbolic scene data; Jev advises maneuvers and risk while conventional code handles flight control and safety.
Pattern: Perception in code → tactical judgment → guarded control.
Scope: Simulation rather than real-world flight; Jev receives JSON rather than images and is advisory. The author reports one successful course run with substantial run-to-run variance.
Original material: the jev-drone authors · MIT · Unmodified · Source · License and attribution
A harness reads structured game state, asks Jev to choose commands, and executes mouse and keyboard actions in the original StarCraft shareware mission Strongarm.
Pattern: Structured strategy-game state → command selection → input execution.
Scope: The game pauses during state reads and inference. The author provides completion evidence for a bounded mission; this is not a real-time competitive-play benchmark or pixel-only agent.
Demo material: Original videos and evidence bundle (1× and 8× playback)
Jev judges threats, suspicion and intentions for guards; server code controls legal actions, physics and fallbacks.
Scope: Scripted mode is available; a recorded live run does not establish repeated success.
Original author material: Game demonstration frame. Measurements shown are author-reported, not SeeAPI tests. MIT · Source · License and attribution
Demo material: Original 37-second film
Jev selects Minecraft actions from structured observations; Mineflayer executes them with code-supplied candidates and checks.
Scope: The earlier video used high-level control; the newer direct-action controller is a separate experiment, not screenshot-based vision.
Eight Python examples apply typed judgments to engineering workflows such as CAD, BOMs and change control, with decisions made in code.
Scope: Small synthetic examples and uncalibrated thresholds do not establish suitability for real engineering decisions.
Combines inclusion choices and atomic eligibility judgments for title-and-abstract screening against an author's documented review protocol.
Scope: The current README evaluates Cohen ADHD abstract triage; limited abstracts and filtering rules can miss eligible papers. This is a research workflow.
An author demonstration combines a simulated JFK airport with real-time voice models for radio interaction and Jev for operational judgments. It illustrates separating voice interaction from a bounded decision loop.
Pattern: Simulated airport state and radio interaction → Jev judgment → simulated response.
Scope: Evidence is the author’s public post and demonstration; no public implementation or complete request trace was verified. It is a simulation, not evidence of real air-traffic-control capability. Timing and judgment quality were not measured here.
Reviewed: 2026-09-18.
Jack Cheng’s author demo combines voice, pointing, and canvas state to present Jev action and target judgments for manipulating shapes. It is a creative-tool interaction example rather than a general image-generation model.
Pattern: Voice/pointing inputs and canvas objects → action and target judgment → canvas operation.
Scope: Evidence is the author demo recorded in the collection; the original post was re-opened, but this pass did not independently replay the full video. No source implementation or request trace was verified, so perception dependencies and end-to-end latency remain unknown.
Reviewed: 2026-09-18.
Evaluates prompt-injection detection and vulnerable-code judgments with published datasets and per-sample results.
Scope: Reported results depend on context and thresholds; this is not an NSFW benchmark or a complete security boundary.
Original author material: Author security benchmark dashboard. Measurements shown are author-reported, not SeeAPI tests. MIT · Source · License and attribution
Studies question framing and failure modes through text tasks, Snake and a 3D city, with reports and recorded traces.
Scope: Synthetic task-specific observations; repeated calls are not independent problems, and assisted control differs from direct control.
Original author material: Snake study interface. Measurements shown are author-reported, not SeeAPI tests. MIT · Source · License and attribution
Demo material: City replay lab · Unassisted Snake runs
Compares Jev relevance rubrics with other rerankers on shared BM25 candidates and publishes saved responses and scoring code.
Scope: The headline averages do not establish a winner; weighting datasets versus queries changes the comparison.
Original author material: Author retrieval evaluation chart. Measurements shown are author-reported, not SeeAPI tests. MIT · Source · License and attribution
Compares direct phishing judgments with atomic Jev signals combined by a local classifier.
Scope: Synthetic emails contain potential shortcuts; direct and held-out experiments have different test sets and must not be conflated.
Demo material: Author benchmark chart
Asks Jev to choose between historical Upworthy headlines and compares choices with recorded click outcomes.
Scope: Historical within-article pairs do not replace a randomized A/B test on a new site's audience.
Compares typed annotation of 12 variables in 120 Portuguese judicial documents with generative-model structured outputs.
Scope: The reference process includes model-generated labels and adjudication; reported accuracy is not based entirely on human gold labels.
Demo material: Author per-field evaluation chart
Source · Implementation / documentation
An adapter adds Jev to an existing chess evaluation framework. For each move, application code provides the FEN position, side to move, and legal UCI candidates; a Choice answer is converted into a make_move action.
Pattern: Board state and legal moves → Choice → move execution and game records.
Scope: Legal candidates are supplied by code, so protocol success does not establish chess strength. Jev and dialog-model players use different interaction protocols; rankings do not establish general reasoning ability. Games and author measurements were not reproduced.
Reviewed: 2026-09-18.
Mike Taylor’s experiment suite breaks writing review, context retrieval, and business triage into bounded judgments. Its writing experiment evaluates 37 documents against 21 criteria; the collection counts the suite once rather than treating its 11 experiments as separate projects.
Pattern: Documents or task state → parallel rubric judgments → flags for further review.
Scope: The reported 777 judgments in under 0.7 seconds are author measurements, not our benchmark. A separate 12-passage synthetic comparison missed one of seven intended defects. Writing-style flags do not prove AI authorship; the experiments were not reproduced.
Reviewed: 2026-09-18.
Source · Implementation / documentation
A maze experiment compares parallel future-step questions with single-step decisions and explicit adjacent-tile hints. The project separates a deterministic BFS mock from real-API runs.
Pattern: Maze state → proposed moves → environment checks → recorded successes and failures.
Scope: The author reports zero solved mazes in the quick multi-step setting; with adjacency hints and one next-move question, 6 of 10 small 5×5 mazes were solved. These are configuration-specific author results, not a reproduced general limit on spatial reasoning.
Reviewed: 2026-09-18.
Jev is TypeSafe AI’s System One model for software automation, focused on fast, structured judgments. Founder Diogo Almeida previously worked at OpenAI on instruction following and conversational capabilities, contributing to the research behind ChatGPT. Jev focuses on decisions within applications: it takes content or application state, evaluates predefined questions and criteria, and returns choices, scores, or probabilities that business logic uses to determine the next action. Official introduction and founder background
Examples include assigning support tickets to teams, filtering relevant context for an agent, choosing the next action, screening external inputs, or classifying a task before routing it to another model. The common pattern is turning repeated, bounded judgments into callable software components.
Choice selects among candidates, Noul returns the probability that a condition holds, and Score rates an input against ordered criteria. Compared with chat models primarily used to generate language, Jev focuses on decisions for branching, ranking, and filtering. Applications still need thresholds, review paths, and fallbacks; probability outputs do not guarantee correct judgments.
Jev is provided by TypeSafe AI. Choose an access route based on where your application runs and whether you need direct API calls or tools for an existing agent. The resources below serve different roles; platform access channels are not counted as additional application cases.
For a standalone application or your first integration, start with TypeSafe's documentation and official SDKs. They provide the baseline API interface used by the Python example below.
| Resource | Purpose | Source |
|---|---|---|
| TypeSafe documentation | Model concepts and API usage | Introduction |
| Official Python SDK | Call the TypeSafe API from Python | typesafe-sdk-python |
| Official JavaScript / TypeScript SDK | Call the TypeSafe API from JS / TS | typesafe-sdk-js |
| Official GitHub organization | Find resources maintained by TypeSafe | typesafe-ai |
Our review found SDKs and developer tools in the official organization, but no official public Jev model-weight repository. Open-source SDKs do not establish that model weights are open; community reproductions are separate projects.
“Third-party” here means a platform other than TypeSafe. Both entries below have documentation published by the platform itself. They can be useful when your application already uses that platform's runtime or model-access interface.
| Platform | When it fits | Documented integration | Sources |
|---|---|---|---|
| Vercel AI Gateway | An application using the AI SDK evaluation interface | typesafe-ai/jev through the evaluation API |
Vercel documentation · Announcement |
| Cloudflare | An application using the Cloudflare AI binding | env.AI.run('typesafe/jev', ...) with state and typed questions |
Cloudflare documentation · Discovery post |
Model IDs, authentication, request schemas, and billing depend on the chosen provider. Follow its documentation rather than mixing examples across platforms. These entries were checked against provider documentation, not tested through paid API calls. Inclusion is not a ranking or a guarantee of cost, speed, or availability.
Use these when an existing agent needs to call Jev judgments as tools. They are software integrations, not separate model-hosting providers or the Jev model itself.
| Tool | Role | Source |
|---|---|---|
| Jev MCP by jkudish | Claim verification, input screening, and semantic candidate ranking | Repository |
| Typesafe MCP by itsmostafa | An evaluate tool exposing typed questions to supported agent clients |
Repository |
Both projects document TypeSafe API-key requirements. Their fuller entries appear in the project collection above and are counted only once. An MCP integration is optional when calling Jev directly from your own code.
We list a channel when it identifies the TypeSafe Jev model, publishes usable integration documentation and provider information, and offers a clear integration benefit. We record its purpose, source, and verification limits rather than maintaining an exhaustive provider directory. Any future listing of SeeAPI must meet the same criteria and disclose that SeeAPI maintains this collection. See contribution requirements.
- Choice: select a candidate, such as billing, technical, or another ticket queue.
- Noul: estimate whether a condition holds, such as whether a message is spam.
- Score: rate against ordered criteria, such as answer quality or risk severity.
Application code connects these judgments to actions. You can use an official SDK directly or expose judgments to an agent through an MCP integration; jkudish/jev-mcp is not a required intermediary.
Install the official SDK:
uv add typesafe-sdkSet TYPESAFE_API_KEY in the runtime environment, then call the API:
from typesafe_sdk import Choice, TypeSafeClient
with TypeSafeClient() as client:
response = client.system_one(
state={"document": "I was charged twice for the same order. Please help."},
questions={
"category": Choice(
instructions="Which category should receive this ticket?",
criteria={
"billing": "Billing, charges, or refunds",
"technical": "Technical failures or integration issues",
"other": "Other issues",
},
),
},
)
print(response.choices["category"].choice)Adapted from the official Python SDK quickstart, with different ticket text and classification criteria. This API request has not been executed for the collection; no example output is fabricated.
Project entries were reviewed against author READMEs, project documentation, implementation files, or explicitly identified author demonstrations. Entries supported only by public descriptions or demos state that limitation. Selected implementation files were inspected; this is not a full code audit. No project was installed, benchmarked, or tested through paid model calls for this collection.
- Project evidence: the linked author documentation or implementation describes a concrete Jev integration.
- Reported measurements: attributed to their authors, with important conditions retained.
- Independent validation: not performed by SeeAPI for this initial collection.
An entry does not imply an official partnership, availability through SeeAPI, production readiness, or endorsement of every claim in its source. Links to default branches may change after the review date.
Initial discovery: 0xLogicrw's Jev project roundup.
Additional case discovery: StudioYebisu’s project roundup, yibie’s roundup, and Nader Dabit’s predictive spreadsheet demo. Repeated projects are counted once; community model reproductions are not counted as integrations of the official Jev model.
Additional discovery directories:
Entries are independently summarized from their linked project sources. Screenshots and demo links show the original authors’ work, not SeeAPI test results. Selected screenshots are reproduced with upstream license and attribution notices; other media remain hosted at their source. Third-party materials retain their own licenses and are not relicensed under our documentation license. See the media source register.
The September 18 follow-up added 19 cases after comparing all 63 records returned by the supplied collection view with the 55 existing entries. It retained existing cases outside that view. See the update review for coverage and verification limits.
See CONTRIBUTING.md to suggest a concrete project or correction. Please update both language versions and preserve source attribution and evidence boundaries.
Original documentation is licensed under CC BY 4.0; code examples are licensed under MIT. Attribute SeeAPI contributors, link to the source and documentation license, and indicate changes when reusing the documentation. Third-party projects and materials retain their own rights and licenses. See licensing scope and third-party notices.