Explore Jev Projects and Build Typed Probabilistic Decision Workflows

What Awesome Jev Provides

Awesome Jev is a curated, source-backed directory of projects built with Jev, TypeSafe AI’s System One model. Rather than being an SDK itself, the repository helps developers discover official resources, community clients, developer tools, workflow integrations, demonstrations, reproductions, and evaluation projects.

Jev is designed for bounded software decisions rather than free-form text generation. It combines unstructured program state with typed questions, then returns constrained answers and associated probabilities. Application code remains responsible for deciding what to do with those answers.

program state + typed questions
→ constrained answers + probabilities
→ deterministic application logic

The directory favors projects with public source code, concrete Jev usage, documented limitations, and reproducible evidence. The listed entries were last reviewed on September 18, 2026, but the ecosystem is described as new and fast-moving.

Understand the Core Decision Primitives

Before choosing a project, identify the kind of decision your application must make. The README highlights three question primitives.

• Choice: Selects from a constrained set of possible answers. This is suitable for classification, routing, triage, and action selection.
• Score: Produces a bounded assessment that can support ranking, prioritization, and rubric-based evaluation.
• Noul: Represents a probabilistic yes, no, or unknown-style decision. It can support verification, moderation, checks, and guardrails.

These primitives are useful when the permitted outcomes can be defined in advance. Jev is not positioned as a replacement for a general-purpose text generator.

Conceptual Decision Loop

The README does not provide SDK-specific syntax, so the following is conceptual pseudocode rather than a directly executable example.

state = collect_relevant_program_state()
question = define_typed_question(
  allowed_answers = ["route_a", "route_b", "abstain"]
)

result = ask_jev(state, question)

if result.probability >= validated_threshold:
    apply_deterministic_action(result.answer)
else:
    request_human_review()

The important pattern is that Jev proposes a constrained decision with probabilities, while ordinary application code enforces thresholds, permissions, and side effects.

Choose a Starting Point

Begin with the official materials before adopting a community integration.

1. Read the System One and Jev introduction for the model interface, published claims, demonstrations, and caveats.
2. Use the official documentation to review concepts, primitives, API details, patterns, and current SDK instructions.
3. Visit TypeSafe AI for the product overview and early-access entry point.
4. Select the official TypeScript and JavaScript SDK or Python SDK according to your application stack.

The JavaScript and TypeScript SDK provides inferred answer types. The Python SDK supports synchronous and asynchronous usage. For provider comparisons, the official System One Python adapter offers a common interface for Jev and LLM providers.

Installation and Setup

Awesome Jev is a catalog, so it has no shared application runtime or universal installation command. Setup depends on the SDK or project you select. Use this process to avoid relying on outdated assumptions.

1. Select a maintained implementation. Prefer an official SDK for a first integration, then consider community clients when you need a specific language or framework.
2. Open the selected repository. Follow its own README for package installation, authentication, environment variables, and version requirements.
3. Consult current API documentation. Confirm the exact constructors, request fields, response types, and asynchronous behavior.
4. Create a minimal typed question. Start with a small set of mutually understandable outcomes.
5. Record answers and probabilities. Keep enough evidence to evaluate accuracy, thresholds, latency, and abstentions.
6. Add deterministic controls. Do not allow a probabilistic answer alone to trigger an irreversible or high-impact action.

Alternative Language and Framework Clients

The directory includes community integrations for several environments. Examples include typesafe-go for Go, jev for Elixir and OTP, and laravel-typesafe-jev for Laravel. Python users can also examine the asynchronous jevclient.

These projects are separate repositories with their own setup instructions and licenses. Inclusion in Awesome Jev is not an endorsement by TypeSafe AI.

Build a Basic Jev Workflow

Step 1: Define a Bounded Task

Choose a decision with a finite output space. Good starting tasks include assigning an incoming request to a queue, rating a record against a rubric, checking whether evidence supports a claim, or ranking a small collection of candidates.

A conceptual routing definition might look like this:

State:
  incoming request, account context, policy metadata

Typed Choice:
  billing | technical_support | abuse_review | unknown

Application rule:
  route only when the selected answer meets a tested threshold

Step 2: Supply Relevant State

Provide the information needed for the decision without expecting the model to invent missing facts. Keep policy rules and important constraints explicit. If a downstream action requires data that is absent, direct the workflow to abstain or escalate rather than guessing.

Step 3: Ask a Typed Question

Use Choice for a finite classification, Score for a bounded assessment, or Noul for a yes, no, or unknown-style check. Follow the chosen SDK’s documentation for the exact request format.

Step 4: Interpret the Probability

A schema-valid response only proves that the result fits the requested structure. It does not prove that the decision is correct. Treat the returned probability as an input to a policy that has been tested against labeled examples.

if confident and action_is_allowed:
    continue_workflow()
elif review_is_available:
    send_to_human()
else:
    stop_safely()

Step 5: Keep Execution Deterministic

Use conventional code to enforce permissions, legal transitions, rate limits, and safety checks. This separation is especially important for moderation, code execution, tool calls, physical devices, and other high-impact operations.

Apply Jev to Common Use Cases

Semantic Routing

For HTTP routing, hono-jev-router routes Hono requests by meaning. tiershift focuses on policy-bounded model routing for TypeScript and Python, while jev-codex-router selects Codex model, reasoning, and speed settings per turn.

Data Filtering and Triage

jev-curate filters and scores Parquet and JSONL streams. jevlogs triages OpenTelemetry logs before more expensive analysis. Database-oriented options include the pg-jev PostgreSQL extension and jevsql for SQL-like filtering, ranking, classification, and scoring with natural-language predicates.

Agents and Guardrails

Agent-oriented projects demonstrate how typed decisions can sit between a model and its tools. jev-guard assigns allow, ask, or deny outcomes to tool calls. winnow judges tool results before adding them to Claude Code context, and Canny records evidence and challenges unsupported completion claims.

These patterns are strongest when the decision layer cannot bypass deterministic authorization. An allow result should still be checked against the application’s actual permission and safety policies.

Interactive and Real-Time Systems

The directory includes games and robotics experiments that separate probabilistic judgment from deterministic world rules. typesafe-snake makes one typed decision per game tick while code generates legal moves. heist-one uses Jev to judge guards while deterministic code controls the game world. jev-drone explores slower tactical decisions in a MuJoCo quadrotor experiment.

Advanced Tips for Reliable Decisions

Calibrate Thresholds on Your Own Data

Do not copy a confidence threshold from an unrelated demonstration. Collect labeled examples from your intended environment and measure what happens at different thresholds. jevcal is listed as a tool for fitting confidence thresholds and checking drift.

Measure Selective Risk and Latency

Allow the system to abstain when confidence is insufficient. Then measure both the accuracy of accepted decisions and the proportion of cases sent to a fallback. jev-benchmarks provides reproducible evaluation focused on calibration, selective risk, and latency.

Compare Decision Approaches

Use controlled comparisons when deciding whether Jev is appropriate for a task. Janus measures when to use Jev versus other models and routes accordingly. The typesafe-ai-benchmark project provides an LLM gateway that imitates the System One output shape for comparison work.

Handle Large Taxonomies Recursively

When a taxonomy is larger than the model’s direct option limit, divide the decision into bounded stages rather than presenting an unrestricted output space. jev-tree demonstrates recursive choice over large taxonomies.

Combine Structural and Semantic Validation

Local schema validation and semantic judgment solve different problems. zod-jev combines Zod shape validation with Jev semantic validation. Even with both layers, validate task performance against representative data.

Preserve Evidence

For each decision, consider recording the input state version, typed question, permitted answers, selected answer, probability, threshold, fallback path, and final deterministic action. This supports audits, error analysis, calibration, and drift detection.

Critical caveat: A schema-valid result is not necessarily a correct decision. Validate on your data, calibrate thresholds, place high-impact actions behind deterministic checks, and provide a human fallback.

Explore Open Reproductions Carefully

The directory also links to independent Jev-like interfaces and open implementations, including openjev-sglang, jevmlx, openvons, and openjev. These are explicitly described as independent efforts rather than official TypeSafe releases.

When evaluating an open reproduction, verify API compatibility, model requirements, hardware support, constraint enforcement, probability calibration, supported modalities, and published limitations. Similar output shapes do not guarantee equivalent behavior.

Contribute a Project

If you have built a Jev project, read the repository’s CONTRIBUTING.md and open a pull request. Small projects are welcome when their public source clearly demonstrates a concrete Jev decision loop. Document the task, typed outputs, probability handling, deterministic controls, limitations, and reproduction steps.

Awesome Jev is released under CC0 1.0 Universal. Every linked project retains its own license, so review that project’s terms before using or modifying its code.

Conclusion

Awesome Jev is a practical map of the emerging System One ecosystem. Start with the official documentation and SDK for your language, build one bounded typed decision, and keep execution under deterministic control. Before production use, evaluate representative data, calibrate thresholds, measure abstentions and latency, and retain a safe human fallback for uncertain or consequential cases.