How to Find and Evaluate Jev Decision Patterns with awesome-jev

What is awesome-jev?

awesome-jev is a curated catalog of public examples involving Jev, TypeSafe AI’s System One decision model. Instead of organizing resources by author, article, or repository, it groups them by the decision being made, such as selecting a tool, ranking context, classifying a threat, or deciding whether information should be retained.

The repository is an index, not the Jev product or an SDK. It is not affiliated with TypeSafe AI, and inclusion does not constitute a recommendation. Its purpose is to help developers discover implementations, inspect the primitives they use, and understand important caveats before adopting a pattern.

A catalog entry means that its link resolved and a person reviewed it. It does not mean the implementation is correct, safe, effective, or suitable for production.

Understanding Jev

Jev accepts state and typed questions, then returns typed answers with calibrated confidence. It is intended for fast, inexpensive decisions inside an agent loop rather than long-form text generation.

The catalog tracks three Jev primitives:

• Choice: used when a decision must be made among available options.
• Score: used when an item or candidate needs a typed score.
• Noul: used for an individual judgment or proposition.

Do not assume that different primitive arrangements are interchangeable. The README specifically warns that a single Choice across several options and one Noul for each option answer different questions. This distinction is a common source of implementation errors.

Jev accepts text input, including strings, JSON objects, and arrays of text. The documented request context is 64,000 tokens, with 32,000 tokens available for the state plus the longest question. There are no published model weights, so Jev cannot be run locally.

Key features of the catalog

Decision-oriented organization

The primary index groups entries by reusable decision patterns. This makes it easier to answer questions such as “How are agents selecting tools?” rather than searching through unrelated posts that happen to mention Jev.

Searchable and shareable views

The searchable site provides filters, entry cards, a coverage histogram, and shareable URLs. It also includes dedicated primitive and compatibility views.

Evidence and caveat metadata

Entries identify their source, implementation language, and the primitives actually called by the code. They may also carry caveats such as shadow mode, vendor numbers, unverified, or no licence. Full notes are stored in catalog.json and displayed on the site.

Coverage and research gaps

The coverage view shows how many public examples exist for each decision pattern. A zero indicates a research gap rather than a display problem. This is useful both for discovering established patterns and identifying plausible applications that have not yet been publicly demonstrated.

Independent measurements

A dedicated section highlights measured results instead of promotional claims. Several entries report negative or neutral findings, including evaluations where Jev underperformed an existing summarizer, tied an incumbent classifier, or increased billed input without providing meaningful latency improvements.

Installation and setup

Option 1: Use the hosted catalog

No installation is required for normal research. Open the hosted site, select a decision pattern, and inspect the matching entries.

1. Open the searchable site.
2. Choose a bar in the coverage histogram to filter by decision pattern.
3. Open an entry and review its source, language, primitives, and caveats.
4. Copy the resulting URL if you want to share the filtered view.

Option 2: Clone the repository

Clone the project if you want to inspect its source data, documentation, examples, or generation scripts locally.

git clone https://github.com/kydlikebtc/awesome-jev.git
cd awesome-jev

The README is generated from catalog.json. The repository explicitly instructs maintainers to edit the catalog rather than editing the generated README directly. To rebuild it, run the documented command from the repository root:

python3 scripts/build_readme.py

The README does not specify additional installation steps in the provided material. Consult the repository files and automation configuration before modifying or validating the catalog.

Basic usage: finding a relevant implementation

Step 1: Define the decision

Begin with the decision your system must make, not with a broad technology label. For example:

• Which tool should the agent call next?
• Which files should be included as review context?
• Does a previous tool result still matter?
• Which threat category best matches a news item?

Step 2: Select the corresponding pattern

Use the site’s coverage histogram or the README’s decision-pattern sections. For an agent choosing its next action, start with Tool selection. The catalog includes examples ranging from function calling and skill suggestion to browser control and permission review.

Step 3: Filter by primitive

Use the primitives view when your architecture already suggests a question type. A closed-set action selection may lead you toward Choice examples, while independent relevance judgments may lead you toward Score or Noul examples.

Primitive labels should be treated as descriptions of what the referenced code calls, not as guarantees that the implementation selected the best primitive.

Step 4: Read the caveats

Before opening a linked project, inspect its warning tags and catalog note. For example, an integration marked shadow mode may be connected to a system while deliberately preventing its decisions from affecting production labels, caches, or alerts.

Step 5: Inspect the original source

Use the catalog for discovery, then verify behavior in the linked repository or documentation. Confirm how state is constructed, how questions are typed, what thresholds are used, and what happens when confidence is low.

Example research workflows

Learning the three primitives

For a first introduction, follow the repository’s recommended reading order:

1. Read the official quickstart for a request containing Choice, Score, and Noul questions.
2. Read the Jev 1.13 known limitations.
3. Inspect the catalog’s three-primitives example.

The repository notes that its local example was checked field by field against the official API reference but was not executed against the live API. Preserve that distinction when assessing it.

Researching tool selection

Suppose you are designing an agent that must select one tool from a large catalog. Search the Tool selection pattern and compare implementations such as:

• The official function-calling cookbook, which maps requests to typed functions using closed-set questions.
• The skill-suggestion cookbook, which evaluates whether a skill is needed and ranks candidate skills.
• FastMCP’s experimental Jev search transform, which performs coarse ranking before judging shortlisted tools.
• Composio’s provider, which reconstructs tool calls and handles abstention or confirmation-required cases.

Comparing these entries reveals architectural choices that a simple popularity ranking would hide, including staged retrieval, explicit abstention, and separate confirmation handling.

Evaluating context selection

If you want Jev to rank files or memories, start with measured examples rather than promotional demonstrations. The catalog reports that the no-mistakes review-context experiment used one Score per candidate file and found materially more billed input with essentially no wall-clock improvement. That result does not prove the pattern is always ineffective, but it provides a concrete reason to benchmark it against a simpler baseline.

Advanced tips

Prefer independent measurements

Prioritize benchmark entries that publish methods, baselines, failures, and raw or reproducible evidence. The catalog highlights the Hermes Agent compaction evaluation because it compared Jev with an existing summarizer and published a decision not to adopt the approach.

Likewise, a neutral result can be useful. The worldmonitor integration remained in shadow mode after a blind evaluation found that Jev only tied the incumbent model. This is a practical model for testing a new decision system without immediately allowing it to affect production behavior.

Test option-order sensitivity

One independent report found that reversing the order of options changed a probability enough to cross a 0.9 threshold. The result is unreplicated, so its magnitude should not be treated as universal. However, it suggests a valuable robustness test:

1. Run the same decision with the original option order.
2. Shuffle or reverse the options without changing their meaning.
3. Compare selected answers and confidence values.
4. Check whether operational thresholds are crossed.

If a harmless reordering changes production behavior, the threshold may be less stable than it appears.

Compare equivalent budgets and simple baselines

Always compare Jev with the system it would replace. Include simple alternatives such as recency ordering, deterministic rules, an incumbent classifier, or a dedicated reranker. Where context budgets differ, compare results at matched budgets so that the evaluation isolates decision quality rather than extra input.

Separate typed output from correct output

Typed answers improve integration ergonomics, but they do not guarantee that the underlying decision is correct. Validate accuracy, calibration, latency, cost, and failure behavior on data representative of your application.

Design for abstention and review

Examples in the catalog include explicit abstention, confirmation-required cases, shadow deployments, and opt-in features. These patterns are especially useful when a wrong high-confidence answer could trigger an unsafe or expensive action.

Check compatibility before implementation

Review the repository’s compatibility documentation for cross-platform differences. Do not assume that examples written in Python, JavaScript, TypeScript, Go, or another language expose identical behavior or integration details.

Use catalog data correctly

When editing the project, treat catalog.json as the source of truth and regenerate the README afterward. The repository badges identify the catalog data as CC0-1.0 and the project code as MIT licensed, but you should still inspect linked projects individually because their licensing may differ or be absent.

Common mistakes to avoid

• Treating the catalog as an endorsement: inclusion only indicates that a link was reviewed and resolved.
• Choosing examples by star count alone: popularity does not establish correctness, calibration, or suitability.
• Confusing Choice with independent Noul judgments: these arrangements answer different questions.
• Trusting vendor performance figures without a baseline: prioritize independent, reproducible measurements.
• Ignoring negative results: failed or neutral experiments often provide the most actionable engineering guidance.
• Assuming typed output guarantees correctness: validate decisions against labeled or otherwise defensible ground truth.
• Editing the generated README directly: update catalog.json and run the build script instead.

Conclusion

awesome-jev is best used as an evidence-oriented research map for Jev integrations. Start with the decision your system needs to make, filter examples by pattern and primitive, inspect caveats, and verify every claim in the original source. Before adopting a design, reproduce it on your own data, compare it with simple baselines, test confidence stability, and plan for abstention or human review.