10 Jev Projects on GitHub You Should Check Out

Agents make dozens of small decisions before producing useful output: which source to trust, which tool to call, what context to keep and when to stop. Jev brings those hidden choices into the open by turning them into typed decisions with probabilities, instead of relying on free-form text alone. 

That makes it useful across browser agents, code reviewers, context-pruning tools, search workflows, routers and mobile automation projects. In this article, we’ll look at ten GitHub repositories that show practical ways to build with Jev. 

What Is Jev? 

Jev is TypeSafe’s System One decision model. You give context, called state, and questions with predefined output types. It returns decisions and probabilities rather than writing an answer in free text. 

The API supports choices from a supplied list, scores and yes-or-no judgements. That makes it useful for routing, ranking, filtering, and checking progress. Your application still defines the available actions and executes them. A valid output type does not guarantee a correct decision. 

Read more: Jev Explained 

1. Jev Ultrafast 

Best for: Developers exploring browser agents with explicit action choices. 

Jev Ultrafast turns the current page into an action table. Jev chooses an operation and an observed element ID, and the browser executes the action. 

The project also uses a separate text model to write input for TYPE_TEXT. Jev handles the decision; another model handles text that cannot be selected from predefined options. 

Useful features: 

• Browser operations and targets are selected together. 
• An inspector following the action loop. 
• A recorded Google Flights example in the repository. 

GitHub: Jev Ultrafast 

2. Fast Jev Compaction 

Best for: Developers trying to control the context used by coding agents. 

Long tool outputs can crowd an agent’s conversation history. Fast Jev Compaction uses Jev’s judgements about tool calls and results to decide what to keep, truncate or drop. It retains the original user and assistant text instead of generating a replacement summary. 

This connects to context engineering: decide what the next turn needs, then remove lower-value material. Pruning can still discard useful evidence, so inspect the retained history. 

Useful features: 

• A standalone npm package and Claude Code plugin. 
• Preservation of recent and initial messages. 
• Fallback to built-in summarisation in the plugin when pruning cannot be used. 

GitHub: Fast Jev Compaction 

3. SemIf 

Best for: Developers who want to explore typed decisions with local open models. 

SemIf reads probabilities for predefined options from an open model’s logits. The application receives a typed decision without asking the model to generate an answer and then repairing its JSON. 

SemIf was formerly called OpenJev and now uses the repository path SemIf-OpenJev. It is independent of TypeSafe. It does not provide Jev’s weights or reproduce its undisclosed architecture and training. 

Useful features: 

• Direct scoring of supplied answer options. 
• Backend options for CUDA, Apple Silicon and CPU/GGUF use. 
• Examples for testing the decision interface locally. 

GitHub: SemIf 

4. Jev Trader 

Best for: Studying how a typed decision feeds into an automated execution loop. 

Jev Trader is an experimental bot for the Kuru MON-USDC order book on Monad. It asks for a buy-or-sell direction and uses that decision to place a limit quote. A dashboard streams the order-book events and bot activity. 

You can inspect how the market state becomes a decision and then a quote. The repository does not establish that the strategy is profitable. 

Useful features: 

• A TypeScript bot built with Bun. 
• Streaming events and monitoring dashboards. 
• A dry-run mode with simulated fills. 

GitHub: Jev Trader 

5. Hermes Jev Skills 

Best for: Adding decision steps to an existing agent workflow. 

Hermes Jev Skills packages Jev for model routing, memory relevance, context compaction, skill selection and other agent choices. The primary LLM continues to write responses while Jev helps decide how the workflow should proceed. 

The basic concepts behind agentic AI explain how these components fit together. You can add one decision skill without rebuilding the entire agent. 

Useful features: 

• Several decision skills with configurable profiles. 
• Integrations for Hermes and coding agent workflows. 
• Shadow routing that logs recommendations before enabling model changes. 

GitHub: Hermes Jev Skills 

6. Jev Review 

Best for: Exploring a decision-based review layer for code changes. 

Jev Review examines a Git diff or a selected source scope. It uses typed judgements to assess potential problems, select evidence, and assign severity. You can inspect the findings on a local dashboard. 

The project covers areas such as correctness, security, reliability, compatibility, and test gaps. Treat the output as a set of reviews leads to investigation. A severity score does not prove that a bug exists. 

Useful features: 

• Review of changes or broader source scope. 
• Findings with supporting evidence and severity. 
• A dashboard for inspecting the review. 

GitHub: Jev Review 

7. Foreman 

Best for: Supervising a coding agent across several work steps. 

Foreman sits above coding workers such as Codex and OpenCode. Jev assesses signals including progress, completion, stuckness and whether human input is needed. A deterministic Python policy then chooses whether to continue, steer, verify or stop the worker. 

This makes it useful for exploring the difference between an agent and its surrounding runtime or harness. The supervisor manages the process; the coding worker performs the task. 

Useful features: 

• Separate judgement and control policy layers. 
• Several supported coding-worker integrations. 
• An offline demo for inspecting the workflow. 

GitHub: Foreman 

8. Jev Search 

Best for: Building search workflows that return ranked sources. 

Jev Search uses Jev to choose search sources, time ranges and search terms, then ranks results obtained through Search1API. It returns links, snippets, and relevance information rather than generating a final answer. 

You can use it as a component in a research assistant or retrieval workflow. This guide to agentic RAG architectures explains how source retrieval fits into a larger agent system. 

Useful features: 

• Search planning with typed decisions. 
• Result ranking and relevance filters. 
• A default Jev provider with additional provider options. 

GitHub: Jev Search 

9. Mobile Jev 

Best for: Exploring Android agents with a visible action trace. 

Mobile Jev lets Jev choose Android operations and targets while Mobilerun executes them on a device. The repository includes a React studio, a CLI and traces for following the run. It does not require an ADB connection. 

The recorded Uber demo shows the agent moving through the app. It should not be read as proof of a completed booking. 

Useful features: 

• Android actions are selected through typed decisions. 
• A studio for observing the device and trace. 
• CLI supports running goals. 

GitHub: Mobile Jev 

10. Jev Router 

Best for: Trying automatic model selection inside familiar coding CLIs. 

Jev Router routes fresh turns in Claude Code and Codex between configured model tiers. Straightforward requests can go to a faster tier while more demanding ones can go to a stronger tier. The native CLI continues to handle tools, sessions, and permissions. 

Useful features: 

• Routing inside the existing coding interface. 
• The selected tier is retained through tool-loop continuations. 
• A fallback that preserves the current model if routing fails. 

GitHub: Jev Router 

Which Repository Should You Start With? 

Choose the project closest to a workflow you already understand. Jev Ultrafast and Mobile Jev make actions visible. Fast Jev Compaction gives you a concrete context-management experiment. Jev Review and Foreman suit coding workflows. SemIf is the option to explore if your priority is running typed decisions locally. 

For an existing agent, Hermes shadow routing is a useful first step because you can inspect recommendations before enabling model changes. Whatever you choose, define what success looks like and verify it outside the decision model. Reading an LLM guardrails guide offers relevant ideas for validation and control. 

Frequently Asked Questions