How to Explore and Evaluate Real-World Jev Typed-Decision Projects

What awesome-jev Is

awesome-jev is a curated directory of public projects and practices built around TypeSafe AI's Jev System One model. It is designed as a fast-scanning field guide for discovering where Jev is making concrete decisions and which implementation patterns may transfer between industries.

Jev is not a conventional chat model. It receives unstructured state together with a typed question and returns a typed decision, such as a choice, score, or boolean, along with confidence. Applications can use that result as a bounded decision layer for classification, routing, scoring, verification, and agent guardrails.

A project appearing in awesome-jev has met the repository's inclusion rules, but it has not necessarily passed a code review, security audit, reproducibility check, or maturity assessment.

Key Features of the Directory

Application-focused categories

Every entry belongs to exactly one category, selected according to its most direct Jev application. The current directory covers areas including:

• Classification and routing: model selection, email intent routing, recruiting, browser filtering, and fault triage.
• Verification and guardrails: code review gates, tool-call safety, prompt-injection checks, and completion verification.
• Scoring and ranking: search relevance, citation support, code quality, SEO, and semantic mapping.
• Agent decisions: browser actions, coding-agent judgments, context pruning, and bounded robotic actions.
• Data labeling and curation: dataset filtering and issue triage.
• Evaluation and benchmarking: comparative tests, calibration tools, and reproducible evaluation harnesses.
• Calibration and research: local reproductions, open alternatives, and Jev-shaped decision models.
• Infrastructure and integrations: SDKs, gateways, command-line tools, and framework integrations.
• Domain categories: games, simulation, finance, trading, compliance, legal workflows, and content moderation.
• Related practices and discussions: credible public reports of real usage when a strong standalone project page is unavailable.

The repository also identifies categories that are still being seeded. For example, the README currently lists Scientific Pipelines with no entries.

Compact, evidence-oriented entries

Each accepted item links to a public source and summarizes the scenario, method, and value in one sentence. An entry must explicitly identify Jev, reference TypeSafe AI's System One approach, or demonstrate a typed loop in which a question produces a typed answer with confidence and the application accepts, rejects, or escalates it.

A generated homepage

The main README aggregates the category files. It is generated by scripts/build-readme.py, so contributors should edit the relevant category file rather than changing generated category content only in the README.

Installation and Setup

Browsing without installation

awesome-jev is a directory rather than an SDK, framework, or executable application. You can use it directly on GitHub by opening the README, selecting a category, and following links to individual projects. No package installation or API credential is required to browse the list.

Working with a local copy

If you want to search the files locally or prepare a contribution, clone the repository using its GitHub URL:

git clone <repository-url>
cd awesome-jev

The category source files are stored under categories/. Useful examples include:

categories/classification-routing.md
categories/verification-guardrails.md
categories/scoring-ranking.md
categories/evaluation-benchmarking.md

After editing a category file, rebuild the aggregate README with scripts/build-readme.py. Follow the repository's own environment and contribution instructions before running it. If the script is configured for direct Python execution, the command will typically be:

python scripts/build-readme.py

Consult CONTRIBUTING.md for the authoritative rules, especially those covering AI-assisted work, project depth, and bulk submissions.

Basic Usage: Finding a Suitable Jev Pattern

Step 1: Define the decision, not the industry

Start by describing the narrow decision your software must make. Ask whether the required output is a choice, score, or boolean and what should happen when confidence is insufficient.

A conceptual decision contract might look like this:

State: the relevant unstructured input
Question: one narrowly defined typed question
Decision: Choice | Score | Boolean
Confidence: model confidence in that decision
Action: accept | reject | escalate

This is a conceptual pattern, not Jev API syntax. Use the API and SDK documentation linked by the specific project you choose.

Step 2: Choose the closest direct category

If your system must select a model, classify an email, or route a request, begin with Classification and Routing. If it must approve an agent action or verify completed work, start with Verification and Guardrails. Use Scoring and Ranking when the output is primarily a graded value or ordering.

Do not search only by industry. A routing pattern used by a coding agent may still transfer to customer support, document processing, or another domain if the typed decision has the same shape.

Step 3: Compare concrete examples

Suppose you need to route requests between models. The directory includes several relevant approaches:

• jev-router asks Jev to choose among candidate models based on the task.
• pi-jev-router adds per-request model routing to the Pi coding agent through Vercel AI Gateway.
• jcm-router selects a Claude model and reasoning effort per message while preserving the cached primary conversation.
• duet-agent maintains a Jev-backed routing table for model selection.

These entries share a typed routing pattern but differ in runtime, target application, and integration boundary. Follow each source link and inspect the implementation before selecting one.

Step 4: Trace the complete decision loop

A credible implementation should show more than a Jev-related claim in its README. Look for the complete path:

1. The application gathers the state required for a decision.
2. It sends a narrowly typed question to Jev.
3. It parses the typed result and confidence.
4. Application code compares the result with an explicit policy or threshold.
5. The system accepts the result, rejects it, or escalates the case.

For example, the listed Notra integration routes brand-visibility classifiers to Jev boolean decisions under its NOTRA_JEV_CLASSIFIERS flag and documents a 0.5 threshold. This is more actionable than a project that merely states that it uses AI classification.

Step 5: Run the project's own evidence

Once you identify a candidate, leave the awesome list and follow that project's setup instructions. Prefer entries with tests, sample inputs and expected outputs, or a public demonstration. The awesome-jev repository does not verify that listed software compiles or that its published results reproduce.

Practical Exploration Examples

Building a guardrail for agent actions

Open the Verification and Guardrails category when you need to inspect an action before execution. Relevant listed patterns include checking risky Pi tool calls with pi-jev, blocking prompt injection or dangerous actions with jev-guard, and comparing every side-effecting tool call with the user's request through pi-heed.

When evaluating these projects, identify exactly where the gate runs. A pre-execution gate can prevent an action, while a post-edit reviewer can only detect or report a problem after a change has occurred.

Scoring and reranking results

The Scoring and Ranking category includes search reranking, citation verification, code-quality assessment, and content grading. Examine whether Jev produces one overall score or several dimensions that application code later combines.

Also review the Evaluation and Benchmarking category before assuming reranking will improve a system. One listed measured report states that Jev reranking alone did not outperform vector retrieval on its tested catalog and query set. Negative results can be as valuable as successful examples when selecting an architecture.

Managing low-confidence decisions

Confidence should drive an explicit application policy rather than being displayed and ignored. A common architecture is to accept high-confidence typed decisions while sending uncertain cases to a human or a more expensive model. The listed jevcal project is especially relevant: it fits per-question thresholds to target accuracy on labeled data, checks them on a held-out split, reports escalation traffic, and can fail CI when a model update breaks locked thresholds.

How to Evaluate a Listed Project

Because curation is not endorsement, apply a consistent checklist before adoption:

1. Confirm a real Jev call. Find a request containing typed questions and code that parses the answer.
2. Look for a runnable check. Prefer tests, examples with expected results, benchmarks, or public demonstrations.
3. Trace quantitative claims. Accuracy, cost, latency, and volume figures should link to reproducible or clearly documented evidence.
4. Measure implementation depth. Determine whether the repository contains working code, a thin scaffold, or primarily prompts and documentation.
5. Check the license. A missing or incompatible license can prevent reuse and redistribution even when the code is public.
6. Review history and maintainership. Same-day repositories with similar scaffolds and minimal commit history may be legitimate, but they remain unproven.

Treat directory entries as research leads. Independently assess security, reliability, maintainability, and licensing before using them in production.

Advanced Tips

Separate model judgment from application policy

Keep the typed decision and confidence separate from the action your system takes. Thresholds, escalation paths, spending limits, and safety rules should remain visible in ordinary application code. This makes behavior easier to test and change without rewriting the decision question.

Prefer narrow questions

Jev examples in the directory are strongest when they ask bounded questions: which candidate to choose, whether a rule is violated, how strongly evidence supports a claim, or whether work is complete. Avoid treating a typed-decision model as a replacement for open-ended generation.

Design an abstention path

Do not force a weak match into a confident-looking action. The listed agent skill router explicitly uses confidence-aware decisions so weak matches can be declined. Similar fallback behavior can be applied to classification, verification, and moderation workflows.

Validate thresholds on your own data

A threshold reported by one project is not automatically appropriate for another. Gather representative labeled cases, select a target quality level, measure coverage and escalation rate, and verify the result on held-out data. Re-run the evaluation after changing the question, model, input format, or decision policy.

Use category files for focused review

The generated README is convenient for broad discovery, but individual files under categories/ are better for focused review and contributions. Since each entry appears in exactly one category, also inspect adjacent categories when a project spans several concerns.

Study open alternatives carefully

The Calibration and Research category includes local reproductions, independent previews, and open Jev-shaped models. These projects may reproduce the typed-decision interface or explore related decoding techniques, but they should not automatically be assumed to match the behavior, calibration, or operational characteristics of TypeSafe AI's Jev.

Contributing an Entry

A proposed entry should be public, citable, and demonstrably connected to Jev or a documented Jev port or derivative. It should describe a concrete typed decision rather than a generic classifier, router, or judge that only resembles the pattern.

1. Select the category closest to the project's direct application.
2. Edit that category's source file under categories/.
3. Write a one-sentence summary covering the scenario, method, and value.
4. Verify that the linked source explicitly demonstrates Jev or the typed-decision loop.
5. Rebuild the generated README with scripts/build-readme.py.
6. Follow all instructions in CONTRIBUTING.md before opening a pull request.

Corrections and removals are valid contributions. If an entry is inaccessible, incorrectly categorized, too vague, or no longer satisfies the inclusion rules, open an issue or pull request with supporting evidence.

Conclusion

awesome-jev provides a structured way to discover real typed-decision applications across routing, scoring, verification, agents, research, and infrastructure. Its greatest value is not simply the number of links, but the recurring patterns those projects expose. Use the list to find candidates, trace each decision loop, test the original project, calibrate on your own data, and treat every listing as a lead rather than an endorsement.