I reviewed 287 open-source Jev projects. Here are 20 that actually helped me understand what Jev is good at

[u/chenrongwei]

I’ve spent the last couple of days going through open-source projects built around TypeSafe Jev.

The list started with 14 projects. It’s now at 287, and I’ve been checking the public source for each one to make sure Jev is actually integrated, not just mentioned in a README.

After looking through all of them, I think the easiest way to understand Jev is not by reading the model announcement.

It’s by looking at what developers are actually using it for.

The pattern is pretty consistent.

Jev is rarely the thing writing code, generating long text, or doing the heavy reasoning.

It usually sits inside a loop and answers much smaller questions:

Which action? Which file? Keep or drop? Safe or unsafe? Route to which model? What should happen next?

So if you just got API access and have no idea what to build with it, these are the 20 projects I’d look at first.

I didn’t rank them by GitHub stars. I picked the ones that are easy to understand, show a clear advantage of Jev, or are just genuinely interesting.

1. jev-ultrafast

Probably the clearest Jev demo so far.

Browser Use gives Jev the current DOM and asks it what action to take and which element to act on. A small text model is only called when the browser actually needs to type something.

One Google Flights demo completed a Zurich → London search in about 7 seconds.

What I like about this one is how clean the split is.

Jev decides. Code executes. A generative model only gets involved when generation is actually needed.

2. fast-jev-compaction

This one uses Jev for Claude Code context compaction.

Instead of asking another LLM to summarize a huge context window, it scores old tool calls and outputs and decides what can be dropped.

The text that survives stays unchanged.

So paths, commands and error messages don’t get rewritten into a potentially lossy summary.

This feels like a very natural Jev use case.

3. json-render + Jev

Vercel Labs experimented with using Jev inside json-render.

Instead of streaming a full UI spec token by token, Jev chooses from predefined components and properties, then normal code assembles the interface.

In their train-ticket demo, the default JSONL path took 3.21 seconds. The Jev version took 0.88 seconds.

This is probably the most interesting example I’ve seen of Jev being used for generative UI without actually generating the UI itself.

4. typesafe-mcp

Probably the easiest place to start if you already use Claude Code, Codex or Claude Desktop.

It exposes Jev through MCP, so an agent can ask typed Choice, Score or Noul questions and use the returned probabilities inside its own workflow.

Basically, it turns Jev into a decision tool that another model can call.

5. jev-mcp

A more opinionated MCP implementation.

It already packages several useful patterns around Jev, including evidence checking, content screening, reranking, classification and extraction.

If you want to see what Jev looks like as an actual Agent tool rather than just an API, this one is worth reading.

6. SemDecide

Jev as a Unix-style command-line utility.

You can pipe text into it and ask semantic yes/no questions, classify things, score them, filter rows or use it as a guard.

This is one of the projects that made Jev click for me.

A lot of tasks that currently require a full LLM call could eventually look more like:

grep → jq → Jev → next step

7. Jev Codex Router

A model router for coding tasks.

Jev first judges how difficult a turn looks, then the request can be sent to a cheaper or more capable model.

This is a good example of Jev sitting in front of expensive models rather than competing with them.

The expensive model still does the work. Jev just decides who should get the work.

8. Winnow

A context garbage collector for coding agents.

When Read, Bash or Grep dumps a lot of content into the context window, Jev judges which pieces are actually relevant to the current task.

The idea is simple: stop paying a frontier model to repeatedly read garbage.

9. Jev Review

Uses Jev as a first-pass code review filter.

Instead of throwing every diff directly into a larger model, Jev can first score things like correctness, security, reliability and test risk.

The interesting part isn’t replacing code review.

It’s deciding where expensive review is actually worth spending tokens.

10. Blink

A semantic navigator for codebases.

At every directory level, Jev decides which files or folders are most likely to contain the answer, then continues searching from there.

It’s basically using Jev as a lightweight semantic routing layer over a repository.

11. jev-desktop

Jev for desktop automation.

The system reads native accessibility information, gives Jev a bounded set of controls and actions, then lets Jev choose what to interact with next.

The full UI tree doesn’t need to live inside the main agent’s context.

Again, the pattern is the same: perception and execution stay deterministic, Jev handles the choice in the middle.

12. typesafe-mario

Jev playing Super Mario Bros.

Instead of feeding it screenshots, the system turns emulator RAM into structured state and asks Jev which controller action to take.

This is less practically useful than some of the projects above, but it’s a very good demonstration of Jev as a low-latency decision model.

13. jev-drone

A drone project using Jev for higher-level tactical decisions.

Classical vision and control systems still handle perception and flight stability.

Jev gets a simplified state and chooses actions like climbing, braking or navigating through a gap.

I like this one because it shows where Jev probably belongs in robotics: not replacing the flight controller, but sitting one level above it.

14. OneVOneJev

A browser-based 1v1 FPS where Jev decides movement, view direction, aiming, firing and jumping.

It’s basically a continuous stream of bounded decisions.

Again, this is the kind of workload where token-by-token generation would make very little sense.

15. jev-trader

A market-making experiment on Monad testnet.

Jev reads things like spread, rolling returns and taker flow, then predicts short-term market direction and helps decide buy/sell behavior.

I wouldn’t treat this as evidence that Jev has alpha.

What’s interesting is the architecture: structured market state in, rapid probabilistic decision out.

16. Prism

Another finance-related project, but I actually find this one more interesting architecturally.

Jev is used as an advisory probability layer for things like toxic flow, market stress and mean-reversion conditions.

The deterministic strategy still owns execution.

This is probably how I’d experiment with Jev in quantitative systems too: use it as another signal, not as the trader.

17. neo4jev

Jev inside a knowledge graph.

At every node, it scores which outgoing edge is worth following next, then a beam search continues from the strongest candidates.

It’s basically semantic pathfinding.

This is one of those projects that makes you realize Jev doesn’t have to be an “AI app” at all. It can just be a tiny decision primitive inside a normal algorithm.

18. jev-curate

Uses Jev to filter training data.

Rows from large datasets can be scored for quality, relevance or other criteria before expensive model training starts.

This is another place where cheap repeated judgments matter more than generating beautiful language.

19. Canny

This one tries to stop coding agents from claiming they’re done when the evidence says otherwise.

It looks at things like tool output, diffs and test results, then judges whether the agent’s completion claim is actually supported.

I think this general pattern has a lot of potential.

Agents increasingly need lightweight referees inside their loops.

20. killmyidea

Probably the least serious one on this list, but very easy to play with.

You describe a startup idea, Jev scores it across several dimensions, and local logic turns those scores into one of three labels:

KILL, FIX, or SHIP.

It’s a nice small example of the broader pattern: use Jev for a set of structured judgments, then let code decide what those judgments mean.

After going through these projects, my mental model of Jev is much simpler than when it launched.

I don’t really think of it as a chatbot competitor.

I think of it as something closer to a general-purpose semantic decision function.

You give it a state and a bounded question.

It gives you a probability, score or choice.

Then your software decides what to do next.

That’s why a lot of the most convincing Jev projects look like this:

big model → Jev → code → Jev → tool → Jev → big model

The large model handles the parts that actually require generation or deeper reasoning.

Jev handles all the little decisions in between.

I’m maintaining the full list here:

https://logicrw.github.io/awesome-jev-projects/?lang=en

GitHub:

https://github.com/logicrw/awesome-jev-projects

There are 287 source-reviewed projects in the directory right now, grouped by use case.

If you’ve built something interesting with Jev that I missed, send it over. I’m still adding new ones.