Jev AI Projects: 10 Community Builds from Desktop Automation to High-Frequency Trading

Within 96 hours of the early-access launch, independent reviews counted between 100 and 287 open Jev repositories on GitHub — a pace that surprised even seasoned observers of the TypeSafe announcement [1]. What started on September 15, 2026 as a controlled, waitlist-gated API product turned into its own small ecosystem of bots, plugins, and automation tools within days. This breadth of Jev AI projects is exactly what this article is about.

This is Part 4 of the series “Jev AI in Practice.” Part 1 (“What Is Jev AI? TypeSafe’s New AI Model Explained”) introduced founder Diogo Almeida, the $40 million seed round led by DCVC, and RLCD training. Part 2 (“Jev AI Performance in Detail: Architecture and Technical Limits”) covered the 70-to-500-millisecond latency and the three question primitives Choice, Score, and Noul. Part 3 (“Jev AI Use Cases in Practice: 5 Fast AI Decision Patterns for Software”) showed how intent classification and routing work with TypeSafeClassifier in LangChain. This fourth part leaves theory behind and shows ten concrete, publicly available Jev AI projects from the community — sorted thematically from desktop automation to high-frequency trading.

Key Takeaways

• Within days of launch, community reviews counted 100 to 287 documented Jev projects on GitHub [1].
• Nearly all ten featured Jev AI projects follow the same pattern: a compact state goes in, a single Jev call with several parallel Choice/Score/Noul questions comes back, then deterministic code handles execution.
• Use cases range from a 7.1-second Google Flights search to Android automation to market-making bots that re-decide roughly every 300 milliseconds.
• Jev is consistently used as a fast decision layer BEFORE an expensive generative model, never as its replacement.
• The largest known integration by stars is QuantDinger with over 11,700 GitHub stars, which added Jev as a pre-trade decision gate.

The Jev AI Projects Ecosystem: Hundreds of Builds in a Few Days

TypeSafe itself offers Jev exclusively as a hosted API — no published model weights, no self-hosting option, accessible via REST plus Python and JavaScript SDKs [2]. Nevertheless, or perhaps because of that, a broad field of third-party projects grew quickly around the single POST /v1/systemone endpoint and the jev-latest model alias [7][8]. Curated collections like awesome-typesafe and awesome-jev-by-typesafe document this ongoing development and emphasize that Jev delivers “typed judgment” for software instead of free text [4][8]. Within its first week, Jev also became one of the fastest-adopted models in the history of Vercel’s AI Gateway, with early integrations from Vercel, Cloudflare, LangChain, and Langfuse [3].

The architectural core pattern running through practically all the Jev AI projects presented below can be summarized in four steps: an LLM or ordinary code first builds a compact state — often well under 1,000 tokens. A single Jev call then asks several parallel Choice, Score, or Noul questions about exactly that state. The answer comes back as a calibrated, type-safe structure in a fraction of a second, at a cost of around $0.042 per million input tokens with free output tokens [5]. Only after that does deterministic code take over the actual execution — a click, an order, a file access, or a smart-home command. This pattern matches exactly the use cases from Part 3 of this series and explains why Jev shows up in such different domains as browser control and trading alike.

The 10 Most Important Jev AI Projects at a Glance

The following overview sorts ten verified, publicly accessible Jev AI projects thematically: from desktop and browser automation through mobile and smart-home applications and developer tools to high-frequency trading.

1. browser-use/jev-ultrafast

The team behind Browser Use uses Jev in their browser automation agent to pick the next action and the matching page element, while a separate model handles the actual text writing. The division of labor pays off measurably: a Google Flights search from Zurich to London was completed in 7.1 seconds. With over 11,000 GitHub stars, this Python project under an MIT license is the best-known application among the ten featured Jev AI projects. Why Jev fits here: element selection is a classic Choice problem with a bounded option set — exactly what System One models are built for. Repository: https://github.com/browser-use/jev-ultrafast

2. awlevin/typesafe-computer-use

This macOS tool reads the screen via OCR and asks Jev which of four actions — click_item, open_site, type_text, or scroll — makes sense next. The click then fires automatically, without ever sending a screenshot to a large, expensive model. At around 719 stars, the appeal lies in the cost: roughly $0.0002 per step. For computer-use applications that run thousands of steps per session, that price difference is the difference between a prototype and a production-ready tool. Repository: https://github.com/awlevin/typesafe-computer-use

3. lahfir/agent-desktop

Instead of pixels, this project relies on the operating system’s accessibility tree. Jev picks the next button or input field within it — a structured Choice decision over a bounded set of UI elements, with no image interpretation at all. At around 1,400 stars, agent-desktop shows that the Jev pattern transfers to arbitrary desktop applications beyond browsers, as long as a structured state description is available. Repository: https://github.com/lahfir/agent-desktop

4. jarrodwatts/jev-trader

The first of two trading bots on this list operates on the Monad blockchain and acts as a market maker in the Kuru MON-USDC market. Jev decides buy or sell roughly every 300 milliseconds per block and places post-only limit orders. Written in Bun and TypeScript, the project ships with a dry-run mode and an SSE dashboard, has around 1,459 stars, and is MIT-licensed. For block-level market making, latency is directly worth money — Jev’s 70-to-500-millisecond window fits squarely inside the block cadence. Repository: https://github.com/jarrodwatts/jev-trader

5. buberlo/jev-trader

Unlike the similarly named TypeScript project, this is an independent Python rewrite with a noticeably more thought-out architecture. A feature engine builds a state under 400 tokens from market data, and a single Jev call returns six atomic judgments in parallel: regime, direction, toxic flow, liquidity stress, quote environment, and inventory pressure. Only after that do a policy engine, hard risk vetoes, execution, and a calibration log kick in. Within the community, this project is considered one of the most architecturally mature Jev trading implementations, because it fully exploits Jev’s parallelism — many typed questions about the same state in one call [9]. Repository: https://github.com/buberlo/jev-trader

6. OpenByteInc/QuantDinger

QuantDinger is an open-source trading operating system for crypto, stocks, and forex that already launched in 2025 and now has over 11,700 stars. After Jev’s release, the team integrated the model as a “pre-trade decision gate” placed in front of the existing LLM gate. By stars, this is by far the largest known Jev integration. The logic: before an expensive frontier model is asked about a trading decision, Jev filters out obviously irrelevant or risky setups in milliseconds — a pattern that matches exactly the “decision layer in front of a generative model” concept from Part 3. Repository: https://github.com/OpenByteInc/QuantDinger

7. tamaratran/fast-jev-compaction

This Claude Code plugin solves a problem every developer running long AI-agent coding sessions knows well: the context grows too large. Jev decides which tool calls and results are still relevant. Stale sections get dropped or shortened, while important details stay verbatim. With around 4,893 stars, this TypeScript, MIT-licensed project is one of the most widely adopted tools among the ten Jev AI projects covered here — likely because it solves an everyday problem for anyone working with coding agents. Repository: https://github.com/tamaratran/fast-jev-compaction

8. devagrawal09/jev-review

jev-review uses staged Jev judgments to pre-screen code diffs and entire repositories for risk, evidence, and severity before an expensive frontier model is tasked with the actual code review. At around 398 stars and MIT-licensed, this is a smaller but precisely focused TypeScript project. The value lies in pre-filtering: not every diff needs a full, expensive review — Jev quickly decides which changes actually deserve closer scrutiny. Repository: https://github.com/devagrawal09/jev-review

9. droidrun/mobile-jev

Mobile Jev brings the automation pattern to Android. Through the Mobilerun automation platform, Jev picks the next action on the device, complemented by a live studio and detailed execution traces for tracking. At around 264 stars, this JavaScript, MIT-licensed project is smaller than its browser and desktop counterparts, but shows that the same Choice-based decision pattern transfers easily to mobile operating systems. Repository: https://github.com/droidrun/mobile-jev

10. AboveColin/HA-Jev

The last entry leaves the classic agent space and brings Jev into Home Assistant. Instead of rigid if-then rules, Jev makes fast, calibrated decisions about whether an automation rule should trigger in a specific situation — for example based on several simultaneous sensor and context signals. HA-Jev shows that the decision pattern from server applications and trading bots transfers one-to-one to the smart home, where latency and cost per decision matter just as much. Repository: https://github.com/AboveColin/HA-Jev

Conclusion: What the Ten Jev AI Projects Mean in Practice

The ten Jev AI projects presented here show a remarkably consistent picture: whether browser, desktop, smartphone, smart home, or trading platform — the same three-part pattern repeats everywhere: a compact state, a single parallel Jev call, and deterministic execution. This consistency is no accident; it follows directly from the architecture described in Part 2 of this series: short context windows, high parallelism for Choice, Score, and Noul questions, and latencies in the millisecond range.

For developers who want to build their own Jev AI project, it’s worth first checking the curated lists awesome-typesafe and awesome-jev-by-typesafe so existing patterns don’t need to be reinvented [4][8]. Anyone already running a LangChain-based workflow from Part 3 of this series can check whether Jev can be placed as a decision gate in front of expensive frontier-model calls — exactly the pattern that QuantDinger, jev-review, and fast-jev-compaction already use in production. Given the pace at which hundreds of projects emerged in just the first week, it’s reasonable to expect this ecosystem to keep branching out over the coming months — well beyond desktop automation and trading, into practically any software that needs fast, typed decisions.

References

[1] Jev Sorted: What TypeSafe’s System One Model Actually Is, and What Is Still Just a Claim – https://pearpages.com/blog/2026/09/16/jev-sorted-what-typesafes-system-one-model-actually-is-and-what-is-still-just-a-claim

[2] TypeSafe Jev System One Models Release Guide 2026 – https://www.developersdigest.tech/blog/typesafe-jev-system-one-models-release-guide-2026

[3] TypeSafe AI’s Decision Model Jev Becomes Vercel’s Fastest Adopted Launch – https://startupfortune.com/typesafe-ais-decision-model-jev-becomes-vercels-fastest-adopted-launch/

[4] Awesome TypeSafe – https://github.com/AbdelStark/awesome-typesafe

[5] TypeSafe AI Launches Jev Decision Model – https://letsdatascience.com/news/typesafe-ai-launches-jev-decision-model-889a38c0

[6] The Register – https://www.theregister.com/ai-and-ml/2026/09/16/typesafe-ai-debuts-model-for-machines-that-plays-doom/5296711

[7] Introducing System One Models and Jev – https://typesafe.ai/blog/introducing-system-one-models-and-jev

[8] Awesome Jev by TypeSafe – https://github.com/Anil-matcha/awesome-jev-by-typesafe

[9] TypeSafe Unveils Jev, Parallel AI for Deterministic Decisions – https://www.briefia.fr/en/article/typesafe-devoile-jev-ia-parallele-pour-decisions-deterministes

[10] ICYM: TypeSafe AI Launches Jev for Structured AI Decisions – https://www.testingcatalog.com/icymtypesafe-ai-launches-jev-for-structured-ai-decisions/

This article is part of the Jev AI series. Part 5: Jev AI as an LLM-as-a-Judge Alternative: The LangChain Study on Agent Evaluation.