---
author: OOMOL
author_url: https://oomol.com/en/about/
datePublished: 2026-09-18
title: "Teach AI to Choose: 5 Agent Skill Ideas Inspired by Jev"
description: Explore five Jev use cases, from music and game NPCs to Skill
  routing, and connect its decision-making capabilities to your Agent workflows
  through OOMOL’s Cloudflare Workers AI Provider.
lang: en
canonical_url: https://oomol.com/en/blog/jev-agent-skills/
markdown_url: https://oomol.com/en/blog/jev-agent-skills.md
---

![Five Jev application ideas: music creation, game NPCs, idea reviews, Skill routing, and log triage](/blog/jev-agent-skills/en-cover.webp)

You have ten draft headlines. Which ones should you keep? You have installed dozens of Skills. Which one fits the next request? A guard in a game spots someone suspicious. Should they keep patrolling, ask a question, or sound the alarm?

Each task may return just one choice, but making that choice requires understanding the context.

Jev, released in early access by TypeSafe on September 15, 2026, is designed for these decisions. It takes text or structured state and returns choices or scores, together with probability information, according to predefined question types. Developers can use those results to determine what their software does next. [TypeSafe’s introduction](https://typesafe.ai/blog/introducing-system-one-models-and-jev)

Jev currently accepts text input. Images, audio, and video must first be converted into text descriptions or structured fields for evaluation. [Input requirements](https://docs.typesafe.ai/models)

For OOMOL readers working with Agents and Skills, this suggests a useful approach: **identify a recurring judgment in a workflow, define its criteria, and package the decision and follow-up steps into a reusable Skill.**

OOMOL now offers a Cloudflare Workers AI Provider with support for Jev. Once connected, you can call Jev from your Agent workflows and start applying the ideas below to real tasks.

## How Jev Works: Turn Semantic Judgments into Results Software Can Use

Jev is designed for structured decisions. TypeSafe calls this class of models **System One models**. A request supplies a `state` containing the material and context to evaluate, plus `questions` defining the judgments, answer types, and criteria. The model returns typed results that code can use for branching, ranking, or routing. [Technical overview](https://docs.typesafe.ai/introduction)

There are three basic question types:

| Type | Purpose | Output |
| --- | --- | --- |
| **Choice** | Select one predefined option, such as a message category | The selected option, a probability distribution, and confidence |
| **Score** | Evaluate degree against predefined ordered levels | A score, a distribution over the levels, and confidence; the score can fall between levels |
| **Noul** | Judge whether a specific statement is true | A probability of “yes” from 0 to 1, without a separate confidence field |

Questions in one request are evaluated independently and in parallel against the same state. They do not see each other’s answers. If a later judgment needs an earlier result, code must make a subsequent request. [Question types and composition](https://docs.typesafe.ai/primitives)

Generative language models typically produce answers one token at a time. TypeSafe describes Jev as using parallel sampling for constrained outputs, returning decisions and probabilities without generating a free-form text answer. Its training method is **RLCD: Reinforcement Learning for Calibrated Decisions**, which aims to align predicted probabilities with observed frequencies. [Model design](https://typesafe.ai/blog/introducing-system-one-models-and-jev) · [RLCD explained](https://docs.typesafe.ai/introduction/machine-learning-primer)

For a well-calibrated model, events assigned an 80% probability should occur about 80% of the time across many comparable predictions. That is a statistical target, not a guarantee about an individual answer. The `confidence` field on Choice and Score answers summarizes how concentrated the probability distribution is; it is not simply the probability that the selected answer is correct. Code still decides when to act, request more information, or ask for human review, using rules validated against real examples. [Probability and confidence](https://docs.typesafe.ai/confidence)

## A Simple Example: Route a Customer’s Message

Imagine an online store receives this message:

> The lamp arrived today, but the shade is cracked. Please send me a replacement.

A developer supplies that message as the `state` and defines three questions. The results below are **invented illustrations, not outputs from a live model call**:

| Predefined Question | Illustrative Result | How Code Uses It |
| --- | --- | --- |
| Choice: Is this a replacement request, a shipping inquiry, a presales question, or something else? | Replacement 92%, shipping 3%, presales 1%, other 4%; select “replacement” | Route to the replacement support queue according to application rules |
| Noul: Does the customer explicitly request a replacement? | 0.98, or an estimated 98% probability of “yes” | Tag the ticket as an explicit replacement request |
| Score: Is the tone calm, moderately dissatisfied, or highly dissatisfied? | A score near “moderately dissatisfied” | Give the support agent an additional signal to review |

Think of it as a sorting form: **a person defines the questions and options, Jev evaluates the message, and code decides where it goes.** If the message is ambiguous and the probabilities are spread across options, the application can send it for review instead.

The 98% figure refers to the probability of an explicit replacement request. It does not mean the customer is “98% dissatisfied.” Nor has the model completed an exchange: checking the order and policy, drafting a reply, and arranging a replacement require other tools, a generative model, or a support agent.

## Give Generation, Evaluation, and Execution Their Own Roles

Consider a workflow for selecting an article headline:

- A generative model drafts ten options from the source material.
- Jev evaluates them against fixed criteria such as clarity, specificity, and whether the source supports their claims.
- Code aggregates the results and presents the candidates and scores to the author.

The generative model proposes options, Jev evaluates meaning, and code handles calculations and execution. A Skill describes the whole process: required inputs, tool calls, how to handle uncertainty, and what to deliver.

This division also makes debugging more specific. Weak headlines point to the generation instructions. An unhelpful ranking calls for a closer look at the criteria. Incorrect totals require checking the aggregation code.

Community projects already offer several interesting examples. The five below include tools with a `SKILL.md` file as well as applications and libraries. Application examples need additional integration before an Agent can use them as a Skill.

## 1. Music Creation: Choose the Parameters, Then Generate the Notes

[Jev Playground](https://github.com/wustep/jev-playground) breaks music creation into predefined choices: mood, structure, key, meter, tempo, instrumentation, and phrases. Jev selects those parameters, and software expands them into notes, notation, and playback, with MIDI export available.

This gives Skill builders a concrete pattern. A user could describe a purpose, such as background music for reading at night. A workflow could translate that request into parameter choices, call the existing music program, and deliver notation and a MIDI file.

That would be a possible “music planning Skill.” Its controls come from explicit choices: change the mood settings to shape the feel of the music, or adjust the tempo and meter to change the rhythm.

The project also includes an offline mode that uses heuristics and requires no API key. When trying it, distinguish offline output from a real Jev call; hearing music alone does not establish that the model took part.

## 2. Game NPCs: Make a Guard’s Decisions Observable

[HEIST//ONE](https://github.com/AbdelStark/heist-one) is a museum stealth game. Disguises, credentials, lighting, and noise influence the guards’ decisions. Jev evaluates threat, suspicion, tactical intent, and attention targets, while code handles physics, pathfinding, legal actions, and win conditions.

The interface can show the evidence a guard received, the model’s probabilities, and the action that was ultimately executed.

When a guard suddenly gives chase, the developer can inspect what it saw, which judgment changed, and how the program translated that judgment into behavior.

This could become a reusable NPC decision workflow: take the local state a character can perceive, choose an action from a predefined set, and let the game engine validate and execute it. Developers define the available actions and execution rules.

The project defaults to a scripted mode that requires no API key; actual model calls require enabling Jev. Its author has supplied evidence of a real model-backed run, but a single run does not establish reliability across different scenarios.

## 3. Idea Reviews: Ask Every Proposal the Same Questions

[Kill My Idea](https://github.com/monteduro/killmyidea) turns startup idea evaluation into a small application. It asks Jev ten questions covering eight scoring dimensions, the idea’s category, and how clearly it is expressed. Code then weights the scores to recommend KILL (drop it), FIX (revise it), or SHIP (launch it).

The scoring emphasis can change depending on whether the goal is making money, building open source, or having fun.

This suggests an “idea comparison Skill”: take several proposals, evaluate them against the same dimensions, and display their differences side by side. It could help users see which ideas are clearly expressed, which depend on untested assumptions, and which deserve a small experiment first.

Consistent criteria make comparison easier. Scores still need to be checked against reality, particularly whether people need the product and will use or pay for it. The project documentation says successful evaluations are archived on the server by default, with an opt-out option in the form.

## 4. Skill Routing: Leave Room for “No Skill Needed”

As a Skill library grows, choosing the right Skill matters more.

[Jev Agent Skill Router](https://github.com/GodsBoy/jev-agent-skill-router) takes a user request and a Skill catalog, then returns a selected Skill, a no-Skill decision, or a request for review. The project handles routing; other software must load and execute the selected Skill.

For people maintaining many Skills, this is a useful distinction. A router must account for task boundaries as well as relevance. A conceptual question may need no dedicated Skill. Several plausible Skills may call for further checking. A decision to skip a Skill does not necessarily rule out tool use later.

A panel showing the request, candidates, selection, and uncertainty could help maintainers spot overlapping descriptions, unclear responsibilities, or overly broad triggers.

This is a direction worth exploring in an Apps and Skills environment such as OOMOL. The community project provides the idea; integrating a complete router still takes development and validation.

## 5. Log Triage: Decide What Deserves Deeper Analysis

[Jev Logs](https://github.com/reachjalil/jevlogs) adds diagnostic value, priority, and routing judgments to logs. It helps select which logs deserve further analysis by a larger model while preserving the original archive. The project provides both an npm package and a `SKILL.md` file. It handles filtering and routing; root-cause analysis belongs to the downstream workflow.

This pattern fits recurring triage work: identify material that needs attention, then call a model capable of deeper analysis.

Keeping the evidence matters. Archived logs make it possible to check whether the triage step skipped something useful. Any cost savings depend on the actual log distribution, filtering errors, and how downstream models are called.

## Start with a Headline Review Skill

![Headline review workflow: a generative model drafts candidates, Jev evaluates them through an OOMOL Provider, and code aggregates the results for an author to review. A Skill preserves the input requirements, criteria, and review rules.](/blog/jev-agent-skills/en-workflow.webp)

*Figure 1: Generation, evaluation, and review have separate roles. This is a conceptual illustration, not a product screenshot or a measured result.*

To put these ideas to work, start with a bounded task whose results are easy to inspect, such as reviewing headlines.

You could define the task this way:

> Evaluate ten candidate headlines against the original source material. Assess clarity, specificity, and whether each headline makes promises the source does not support. Preserve the individual judgments and flag candidates for human review. The author makes the final choice.

Then make the workflow’s expectations explicit:

| Requirement | Headline Review Example |
| --- | --- |
| Inputs | Source material, intended audience, and candidate headlines |
| Evaluation criteria | Is the topic clear? Is the wording specific? Does the source support the promise? |
| Use of results | Help with comparison and review while preserving each dimension |
| Exceptions | Ask the author to review missing evidence or uncertain judgments |
| Validation | Check real examples, including strong, weak, and ambiguous headlines |

Get this small workflow working before expanding to larger batches or more tools. For Chinese content in particular, TypeSafe says Jev currently performs best in English; other languages need testing on your own examples. [Model and language support](https://docs.typesafe.ai/models)

## Connect the Provider in OOMOL and Start Using Jev

**OOMOL now offers a Cloudflare Workers AI Provider with support for Jev. Connect it to start using the model.** TypeSafe develops Jev, Cloudflare provides access to it, and OOMOL makes that access available within an Agent’s tool workflow. Cloudflare lists [Jev in its model catalog](https://developers.cloudflare.com/ai/models/typesafe/jev/).

Start with the headline review task above:

1. Complete the Cloudflare Workers AI Provider connection setup in the [OOMOL Console](https://console.oomol.com/).
2. Prepare your source material and candidate headlines. Tell your Agent which dimensions to compare and explicitly ask it to call Jev.
3. Review the returned judgments, identify candidates that need revision or a closer look, and decide what to do next.

Once connected, you can give your Agent a request like this:

> Use the connected Cloudflare Workers AI Provider to call Jev and evaluate the following ten headlines. Using the original source material, assess clarity, specificity, and whether any headline makes an unsupported promise. Put the results in a comparison table, preserve each judgment, and list the headlines I should review separately.

The Agent turns the task into questions Jev supports, then organizes the returned results into a table and explanatory prose. Jev handles the judgments within that process.

Once the workflow is working, save the input requirements, evaluation criteria, tool calls, and review rules as a headline review Skill. You can reuse the same process with the next batch of material. Proposal comparison, content classification, and log triage are other possible starting points.

**The Provider gives you access to the model; the Skill preserves the method for completing a task.** The music, game, and routing projects in this article offer design references. Reproducing their full behavior still requires the relevant application code and execution logic.

For guidance on designing judgment questions, see the [official TypeSafe Skill](https://github.com/typesafe-ai/skills). Developers considering another MCP integration can also look at the community [jev-mcp](https://github.com/rashedInt32/jev-mcp) project.

## Good Decisions Need Clear Questions and Checkable Results

Jev makes it easier to include classification, scoring, and selection in software. Developers still need to define the candidates, the evaluation criteria, and what happens when a choice is wrong.

TypeSafe documents limitations involving counting, mathematics, date comparisons, and complex indirect reasoning. Explicit calculations belong in code, and a correctly structured output still needs to be checked for correctness. [Known model limitations](https://docs.typesafe.ai/model-jaggedness/jev-1.13)

These projects suggest a concrete development approach: find a recurring decision in your workflow, supply enough context, define criteria you can test, and connect the result to the next action.

Start by choosing a headline, routing to a Skill, or deciding whether a log needs deeper investigation. Linking inputs, judgments, execution, and review creates a capability you can use again.

## Start in Chat with a Leina Agent

To try what an Agent can do, start with **[Leina Agent](https://leina.ai/)**. Create and run an Agent, chat with it, explore conversational models such as GPT, and add tools as your tasks require them. Available models depend on Leina’s current configuration options.

Leina supports common messaging platforms including **Discord, Slack, Microsoft Teams, WeChat, Feishu, and DingTalk**. Once you connect your chosen channel, you can send tasks from the messaging app you already use on your phone or computer, without deploying a gateway or writing API calls yourself.

Start in three steps:

1. **Create an Agent.** Visit [leina.ai](https://leina.ai/), follow the getting-started entry point, and create and run your Leina Agent.
2. **Connect your messaging app.** Follow the setup instructions for your chosen platform, then send your first message from your phone or computer.
3. **Try a small task.** Ask it to explain a concept, organize text you provide, or draft a few headlines. Add and authorize the relevant Connector when a task needs access to another app.

For example, send it this request:

> Explain Jev with an everyday example, then draft five headlines from the source material below.

As your tasks grow, configure the **Connectors** your Agent needs. These app connections let it access other services within the permissions you grant and carry work forward from a chat request. You can choose different Connectors for your needs and save a working process as a Skill to use again.

To try the Jev evaluation workflow in this article, configure a Cloudflare Workers AI Provider connection with Jev support for your Agent, then send the headline review request above. The conversational model handles ordinary chat and headline generation; an explicit Jev call lets you try its classification, scoring, and selection capabilities.

**[Visit Leina and create your Agent](https://leina.ai/)**, starting with one message. If you already have an Agent, you can also connect the Provider through the [OOMOL Console](https://console.oomol.com/) and keep your existing setup.

---

*Sources and scope: This article is based on research dated September 18, 2026, with TypeSafe’s introduction, model documentation, and limitations checked separately. Community project descriptions come from the author documentation examined in that research; the demos and performance were not independently tested for this article. Provider availability and Leina onboarding and channel support are described using product-team information and Leina’s website; this article does not report a live test of that Provider. Community applications and proposed Skill extensions are distinct from complete applications shipped by OOMOL.*