Jev AIJev examples · open-source projects · reviewed October 11, 2026
From beating Pokémon Red to linting code against plain-English rules: what people build with Jev, and what Jev actually decides in each one.
In the month since TypeSafe released Jev on 15 September, GitHub has gained more than 600 repositories with Jev in the name or description and at least ten stars. We read the ones with real traction, 15 projects with 5,677 GitHub stars between them, and grouped them by the decision Jev makes. Each card says what the project does, where Jev sits in it, and what its author measured. One of them, jevlint, we installed and ran on our own code.
Every project below uses one or more of Jev’s question types. Knowing which one tells you how to copy it.
Choice
Seen in: Pokémon moves, which page answers a question, which bot replies, which engine to search
Let your code build the option list from what is actually legal or available; Jev only chooses. That is why the Pokémon harness never sends an illegal move.
Noul
Seen in: A lint rule per function, “does this event belong to the incident”, “is this request a refund”
One question per rule. Write the exception into the criteria instead of hoping the model infers it; jevlint has an exceptions field for exactly this.
Score
Seen in: Relevance of a file or passage, risk of a pedestrian, urgency of a ticket
Describe every level so the score is anchored. Sort by the score, cut by a threshold you measured.
Featured · games
The most-covered Jev demo, and a clean illustration of the Choice pattern at scale.
The harness reads game memory, lists the legal options with facts about each (type matchups, damage estimates, distance to the objective) and presses buttons; Jev makes every menu, battle, catch and routing decision. The harness never writes to game memory. The design choice that matters is the split of work: code handles everything mechanical (pathfinding, menus, reading memory) and builds a short list of legal moves with the facts a player would know; Jev decides. Hidden items are not shown to Jev, because a human player would not know where they are. Figures are from the project’s README; we did not rerun it, and a run needs your own legally obtained copy of the game.
christianmat/jev-pokemon · GPL-2.0 · 127 stars
Stars as of October 11, 2026. “Author reports” marks numbers we have not reproduced.
Jev answers the “which file”, “does this follow the rule” and “is this worth reading” questions inside a coding loop.
A CLI that finds code by asking what it does, built for coding agents.
Where Jev sits: Jev scores files and then excerpts for relevance to a plain-language question; the agent gets paths, excerpts and line references.
Author reports: The upstream author reports a 28.6% cut in coding-agent cost on ten tuned SWE-bench tasks, Jev inference excluded.
A Claude Code skill that hands bulk “read a lot to decide a little” calls to Jev.
Where Jev sits: Claude calls the skill with many items; Jev returns a typed verdict per item in parallel, and Claude reads only the shortlist.
Author reports: The author reports 86% fewer Claude tokens across a 12-task benchmark scored against hidden ground truth.
A linter for rules written in plain language, such as “join related records in the database”.
Where Jev sits: Tree-sitter extracts functions and other code units; each unit and rule becomes one decision, with exceptions and a confidence threshold. Results are cached per unit.
Our run: We ran it ourselves; the results are in the section below.
A tutorial ladder from one smart if-statement to a coding agent that reaches for Jev on its own, with a YouTube walkthrough.
Where Jev sits: Levels 1 to 5 are plain code calling Jev; levels 6 to 10 put it inside a pi coding agent. 201 offline tests run on a deterministic mock.
An unofficial skill that teaches coding agents to write Jev integrations correctly.
Where Jev sits: Reference material on question types, calibrated confidence and thresholds that an agent loads before writing the code.
Choice over candidates replaces embeddings for picking sources, pages and records.
Web search where Jev picks engines, time range and query rewrite, then ranks results across 12 sources.
Where Jev sits: Choice for routing decisions before the search, Score per result after it, through Search1API.
A permission-aware document drive from Extend that files and searches documents with a decision model instead of embeddings.
Where Jev sits: Hierarchical beam search over categories, documents and sections with Jev or Cloudflare’s Clef, then independent usefulness scoring of source passages before a chat model answers with citations.
Finds the page that answers a question in a 300-page report, with no vector database.
Where Jev sits: “Which page answers this?” as one Choice with a page per option; PageIndex turns long documents into a section tree so each Choice stays under Jev’s 255-option and context limits.
Jev-powered search for Rails apps.
Where Jev sits: Labels records at index time, interprets the query, and streams a reranked result list.
One natural-language decision applied to every row of a dataset.
Runs one natural-language decision over every row of a large table, from Pandas, NumPy or JSON.
Where Jev sits: Reorders rows and fields so repeated context comes first and a prefix-caching backend reuses it; returns decisions in the original row order. Ships a backend for the open JEV-9B on vLLM.
Author reports: The author measures up to 11.7× throughput over the original row order on one RTX 4090, on synthetic workloads.
Long runs of small decisions, where the harness lists legal moves and Jev picks one.
Jev played Pokémon Red to the end credits on a public stream, 25 to 26 September 2026.
Where Jev sits: The harness reads game memory, lists the legal options with facts about each (type matchups, damage estimates, distance to the objective) and presses buttons; Jev makes every menu, battle, catch and routing decision. The harness never writes to game memory.
Author reports: Finished in 37 h 40 min with 16,150 decisions at a median of about 0.4 s each; 16 team wipes, 14 of them at the Elite Four, and 15 Elite Four attempts.
Three trading bots race each other on OKX perpetual futures with simulated money by default.
Where Jev sits: Jev makes every trading decision; every order passes a risk layer written in plain code, and a dashboard shows each decision, order and funding payment.
Author reports: Paper trading by default; the author stresses it is an experiment, not financial advice.
A vision front end turns frames into state, Jev judges each object.
Gives Jev a camera: images, video and RGB-D streams become state Jev can judge.
Where Jev sits: A vision front end detects and describes objects; one Jev call then asks the same question about every object in the frame, such as an accident-risk probability for each pedestrian.
Triage, incident timelines and routing between bots.
Incident response: start from one confirmed-malicious process and let Jev link the rest of the incident.
Where Jev sits: Jev decides which related events belong to the same incident and builds a timeline and execution chain an analyst can review.
A self-hosted multi-bot chat.
Where Jev sits: Jev picks which bot answers each message; a daemon on your machine runs the chosen bot’s turn.
Plain-language lint rules, checked by Jev per function. Here is exactly what we did and what came back.
Downloaded the v0.4.0 macOS arm64 release and checked its SHA-256 against the published checksums. Single binary, no runtime.
One error rule, keys are never printed, and one warning rule, check the HTTP status before parsing JSON. Both are rules we actually follow in this repository.
5 bench scripts from our repository: 125 code units, 102 Jev decisions in 5 seconds, 0 findings. The scripts read keys from files and check every response, so zero was the right answer.
Added one function that logs the key and parses without a status check, next to a clean twin. jevlint flagged both rules on the bad function, nothing on the clean one, and reused 51 cached decisions so the rerun took 1 second.
{
"languages": { "typescript": {} },
"rules": [
{
"id": "no-secret-output",
"description": "An API key or token read by this code is never written to stdout, stderr, a log or an output file.",
"severity": "error",
"kinds": ["function"],
"include": ["src/**/*.ts"]
},
{
"id": "check-http-status",
"description": "A function that calls fetch checks response.ok or the status code before parsing the response body as JSON.",
"severity": "warning",
"kinds": ["function"],
"include": ["src/**/*.ts"],
"exceptions": ["The function does not call fetch."]
}
]
}export async function debugCall(apiKey: string, url: string) {
console.log(`calling ${url} with key ${apiKey}`)
const response = await fetch(url, { headers: { authorization: `Bearer ${apiKey}` } })
return response.json()
}
export async function safeCall(apiKey: string, url: string) {
const response = await fetch(url, { headers: { authorization: `Bearer ${apiKey}` } })
if (!response.ok) throw new Error(`HTTP ${response.status}`)
return response.json()
}Exit code was 1 with both findings on debugCall and none on safeCall. Two rules and six files is a small test: it shows the tool works as described and catches an obvious case, not how it does on subtle ones. For a larger measurement of Jev as a checker, see Jev-as-a-Judge, 300 verdicts with ground truth.
What the strongest projects have in common.
Start in the playground with your own text, then wire it in with n8n, OpenClaw, a coding agent or the API. To run the same patterns offline, see Jev-style models on Ollama.
The most-starred projects on this page are jevgrep (code search for agents), Jevbox (a document drive), Jev Search (web search), SOLO (decisions over every row of a table) and JEV Sees (cameras). The best-known demo is Jev Plays Pokémon Red, which finished the game in 37 h 40 min with 16,150 decisions.
According to the project, yes: the run streamed on YouTube on 25 and 26 September 2026 and reached the credits. The harness reads game memory, lists legal options with facts such as type matchups and damage estimates, and presses buttons; Jev picked every option. The harness never writes game memory, and story milestones are the only game knowledge it supplies.
beebots runs three Jev-driven bots on OKX perpetual futures, on simulated money by default, with every order checked by a risk layer in plain code. Its author describes it as an experiment and not financial advice, and so do we: a decision model choosing trades is not evidence that the trades are good.
The 10 Levels of Jev repository goes from one smart if-statement to an agent that calls Jev itself, with a video and an offline mock. On this site, the playground lets you build a question against your own text, and the Jev agent guide shows where Jev sits in an agent loop.
Most read a TypeSafe key and a base URL. Where a project exposes the base URL, set it to https://jev-ai.pro/api and use a Jev AI key; where it hard-codes api.typesafe.ai, it needs a TypeSafe key. jevlint, for example, takes TYPESAFE_BASE_URL or a full TYPESAFE_ENDPOINT.
Often. Several projects accept any server that speaks the /v1/systemone request shape, which includes Ollama 0.35 and later, Kev and Jeeves. Answers and calibration differ between models, so re-check thresholds; our Jev on Ollama page measures the open models against Jev.
Who. Jev AI runs a hosted endpoint for TypeSafe’s Jev and publishes guides and measurements around it. We did not write and are not affiliated with any project listed here.
How. We searched GitHub for Jev projects created since the 15 September 2026 release, kept those with meaningful adoption or a distinctive pattern, and read each README, licence and recent commit history on October 11, 2026. Results quoted from a project are its author’s; the jevlint run is ours.
When. Reviewed October 11, 2026. We add projects as they gain traction and remove ones that are archived.
Pokémon is a trademark of Nintendo, Creatures and Game Freak. Project names belong to their authors.