20 Open-Source Jev Projects You Can Try in 2026: MCP, Coding Agents, Browser Automation & More

Jev has only been public for a short time, but developers have already put it inside coding agents, browser loops, MCP tools, dataset pipelines, games, robotics experiments and trading systems.

This is not another list of theoretical Jev use cases. The projects below show something more useful: where developers place a decision model inside real software, what Jev is allowed to decide, and which parts remain under deterministic code or a larger generative model.

If you are new to the model itself, start with our explanation of how Jev decision models work. If you are looking for broader application patterns rather than individual repositories, the earlier guide to real Jev use cases covers agent orchestration, research triage, browser automation and other workload types.

One caveat: this ecosystem is extremely young. Many repositories are experiments, demos or single-developer projects. Check the current repository, license, API behavior and safety boundaries before treating any of them as production software.

What These 20 Jev Projects Are Actually Testing

The projects look very different on the surface, but most follow the same architecture:

structured state ↓ bounded decision ↓ ordinary software policy ↓ tool, model or action

The important part is that Jev rarely owns the whole workflow. It usually replaces one narrow fuzzy judgment that would otherwise require another LLM call or a growing pile of heuristics.

Coding Agents Are Becoming Jev's Most Interesting Test Bed

Coding agents generate huge amounts of intermediate state: file contents, command output, stack traces, diffs, test logs and repeated routing decisions. Much of that work does not need another paragraph from a frontier model. It needs selection.

1. fast-jev-compaction — Compress Context Without Rewriting It

fast-jev-compaction replaces the usual summarization-heavy compaction step with relevance judgments over previous tool calls and results.

Low-value history can be dropped or truncated while retained commands, paths, errors and outputs stay verbatim. That makes context compression a selection problem rather than a rewriting problem.

The value is not that Jev writes a better summary. It avoids writing one.

2. Winnow — Stop Irrelevant Tool Output Before It Enters Context

Winnow attacks the same problem earlier in the pipeline. Large Read, Bash or Grep results are split into blocks, then evaluated for task relevance before they consume more context.

The distinction from compaction matters:

• Winnow: filters information on the way into the working context.
• fast-jev-compaction: removes stale information that is already in conversation history.

Together they show two different places where coding agents can replace token-heavy summarization with bounded relevance judgments.

3. Jev Codex Router — Decide How Much Model a Task Actually Needs

Jev Codex Router moves the decision one level higher: before Codex handles a task, Jev selects a model tier and reasoning effort.

This makes Jev a traffic controller rather than a coding model. Easy work can stay on a cheaper route while difficult turns can be escalated.

The repository reports a historical simulation suggesting substantial savings compared with routing every tested turn through its former highest-cost path, but that figure should be treated as a backtest rather than measured current Codex quota savings.

The architecture also connects to a broader question we have explored before: whether a small model can route requests to larger models without becoming the final reasoning engine itself.

4. Jev Review — Spend Review Attention Where It Matters

Jev Review breaks code review into narrower judgments such as which files deserve attention, which evidence is relevant and how severe a suspected problem may be.

The interesting part is prioritization. Jev does not need to generate the final review to improve the workflow; it can first narrow a large diff into the places where deeper reasoning or human review is worth spending.

5. Blink — Navigate a Codebase One Semantic Choice at a Time

Blink treats repository search as path selection.

At each directory level, visible files and folders become candidates. Jev selects the most promising next branch for the current question, and the search continues recursively.

Instead of embedding an entire repository before every query, the system asks a much narrower question repeatedly: where should I look next?

6. Canny — Separate “I Think I'm Done” From Evidence That the Work Is Done

Canny targets agent completion claims.

Deterministic records track what actually happened: files changed, commands ran, tests completed and outputs appeared. Jev can add semantic judgments around that evidence, but the model does not become the ultimate permission layer.

This separation matters for local agents that can modify real systems. Our guide to tool-execution trust boundaries explains the same principle at the broader agent architecture level: deciding that an action looks appropriate is not the same as granting permission to execute it.

MCP and CLI Projects Turn Jev Into Infrastructure

The next group is less application-specific. These projects make Jev available as a reusable decision primitive inside existing tools.

7. typesafe-mcp — Give Existing Agents Direct Access to Jev

typesafe-mcp exposes Jev through Model Context Protocol.

A Claude, Codex or MCP-compatible agent can request a structured Choice, Score or Noul judgment without implementing a new Jev integration for every workflow. The agent still decides when the tool should be called and what to do with the result.

8. jev-mcp — Package Common Decisions as Agent Tools

jev-mcp raises the abstraction level by exposing familiar operations such as classification, scoring, screening and matching.

Instead of every agent inventing a new prompt for the same judgment, common decision patterns can become reusable interfaces with structured outputs.

9. SemDecide — Put Semantic Logic Inside Unix Pipelines

SemDecide explores an even smaller integration surface: the command line.

grep → jq → semantic decision → shell action

This is useful for questions that are difficult to express as a regex but still too constrained to justify an autonomous agent, such as whether a change looks security-sensitive or whether a record belongs to a semantic category.

The key boundary remains deterministic: permissions, destructive commands and production safety checks should stay in ordinary code.

Browser and Desktop Agents: Choose Actions Instead of Generating Them

Browser automation is an unusually strong fit for a bounded decision layer. Once a page has been converted into candidate elements, much of the loop becomes action selection rather than language generation.

10. jev-ultrafast — Generation Only When the Browser Actually Needs Words

jev-ultrafast builds an indexed action space from the current page and lets Jev choose an operation and target element.

A generative model is only needed when the selected action requires new text, such as filling a form field.

The project's Google Flights demo reports roughly seven seconds for one example task, including generation and page waits. That should not be treated as a universal browser-agent benchmark. The more important result is architectural: click selection and text generation do not need to use the same model.

11. agent-desktop — Apply the Same Pattern to Native UI

agent-desktop exposes macOS interfaces through accessibility data and stable element references.

Instead of reconstructing the desktop from screenshots at every step, the system can give Jev a bounded set of controls and actions. Native tooling still performs the actual click, focus or keyboard operation.

This is a useful reminder that better observation often matters more than a larger model.

12. json-render + Jev — Generative UI Without Arbitrary UI Generation

json-render experiments with using Jev to compose interfaces from an application-owned component catalog.

The application defines which components, properties and actions are legal. Jev chooses among those candidates, while normal code assembles and validates the resulting tree.

The Jev composition path remains experimental, but it demonstrates a useful alternative to unconstrained UI JSON generation: let the application define the vocabulary, then let the model choose from it.

Games and Robotics Show Where Jev Should Not Be in Control

Real-time systems make architectural boundaries obvious. Physics, collision handling, safety and fast control loops cannot wait for an uncertain model response.

13. typesafe-mario — Structured Game State In, Legal Controller Action Out

typesafe-mario converts emulator telemetry and RAM into compact structured state rather than sending screenshots to Jev.

Jev then selects from legal controller actions such as moving right, jumping or running and jumping. Timing arithmetic, emulator control and game-state extraction stay in normal software.

The demo isolates the decision problem cleanly: the model does not need to rediscover the game world from pixels before every move.

14. jev-drone — Keep the Model Above the Safety Loop

jev-drone runs an autonomous quadrotor through a MuJoCo simulation.

Fast geometric control, guidance and safety remain deterministic. Jev operates much more slowly as an advisory tactical layer that interprets the current situation.

500 Hz flight control 50 Hz guidance + safety 15 Hz camera → symbolic scene ~2.5 Hz Jev tactical judgment

The project is a simulation, not evidence that Jev should control a real aircraft. Its architectural lesson is stronger than that claim would be: probabilistic judgment belongs above hard real-time safety logic.

15. OneVOneJev — A Game Loop Is Mostly Repeated Selection

OneVOneJev applies Jev to a browser-based one-versus-one shooter.

The server owns physics, networking and legal game state. Jev operates inside that constrained world by choosing movement or combat actions.

That makes the project useful less as a gaming product and more as a stress test for repeated bounded decisions where producing natural-language explanations would add almost nothing.

Trading Experiments: Decision Models Should Not Own the Wallet

Financial demos deserve stricter interpretation. A fast market judgment is not evidence of profitable trading, and an experimental bot should not be confused with a validated strategy.

16. jev-trader — One Direction Decision Per Monad Block

jev-trader watches the Kuru MON-USDC order book on Monad and asks Jev to choose a buy or sell direction once per block.

The surrounding system handles market data, limit-order construction, position constraints and execution. It also supports dry-run operation without a private key.

That boundary is the useful part: Jev contributes a market judgment; ordinary software still owns the trading machinery.

17. Prism — Treat Jev as a Signal, Not the Strategy

Prism takes a more advisory approach. Jev evaluates market conditions such as flow quality, pressure or mean-reversion signals while the strategy and execution layers remain separate.

This is a better general pattern for high-impact workflows: models can contribute probabilistic evidence without inheriting authority over irreversible actions.

Search and Data Pipelines Show Jev Does Not Need an Agent

Some of the strongest projects remove autonomous agents entirely. Jev becomes one semantic operation inside a conventional algorithm.

18. neo4jev — Add Semantic Judgment to Graph Search

neo4jev uses Jev while traversing a Neo4j knowledge graph.

At each node, candidate relationships become a bounded choice. Jev estimates which edge is most promising for the current question, while classical search code handles traversal, visited nodes, beam width and stopping conditions.

This is a useful pattern beyond graphs: replace one brittle heuristic inside an existing algorithm rather than rebuilding the entire application around AI.

19. jev-curate — Score Data Before Spending More Compute on It

jev-curate applies repeated semantic judgments to JSONL or Parquet records before they enter more expensive training, analysis or review stages.

Data curation is a natural decision-heavy workload: millions of rows may need relevance, quality or risk judgments, but almost none require a paragraph of generated text.

The model handles fuzzy evaluation; the pipeline still owns batching, thresholds, storage and final acceptance policy.

20. killmyidea — A Small Demo That Makes the Architecture Obvious

killmyidea asks Jev to evaluate a startup idea across multiple structured questions.

The application then applies ordinary weights, gates and thresholds to turn those scores into a final KILL, FIX or SHIP verdict.

idea ↓ Jev scores ↓ deterministic weighting ↓ KILL / FIX / SHIP

It is a small project, but it captures an important design principle: AI can add useful judgment without being responsible for generating the final product output.

Which Jev Project Should You Try First?

Can You Run These Jev Projects Locally?

In many cases, you can run the surrounding project locally. That does not mean Jev itself is running locally.

As of September 2026, Jev is accessed as a hosted TypeSafe service rather than through publicly downloadable model weights. A local coding agent, MCP server or browser controller can therefore run on your own machine while sending selected decision state to the Jev API.

local files / browser / agent ↓ local harness or MCP server ↓ selected structured state ↓ Jev API ↓ typed decision ↓ local software executes

If keeping the decision model itself on your hardware matters, that is where the architecture changes. Our guide to the open-source local decision model Laya looks at an alternative with downloadable weights that can run on local hardware.

The distinction is useful for homelab and private-AI deployments:

That difference matters more than whether a GitHub README says “local.” A workflow can be locally hosted while one decision step still depends on an external inference service.

The Real Jev Pattern Is Smaller Than an Agent

The most important thing about these 20 projects is not the number of applications developers have already built. It is how consistently Jev appears at one narrow point in the loop.

A browser already knows which elements exist. Jev chooses one.

A coding agent already produced thousands of lines of tool output. Jev decides what still matters.

A router already knows which models are available. Jev chooses a route.

A graph already contains its edges. Jev chooses which one looks useful.

A drone already has a flight controller. Jev contributes a slower tactical judgment.

A trading system already has order logic and risk constraints. Jev contributes a direction signal.

That is what makes the first wave of Jev projects more interesting than another collection of chatbot demos. Developers are testing whether parts of today's AI stack should stop being generative altogether.

The useful question is therefore not whether Jev can replace a frontier LLM.

It is how many expensive, open-ended LLM calls inside today's software were really just bounded decisions waiting for a smaller interface.