---
title: "OpenJev"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/173f3b2e-f55d-4777-9609-91685a1f0a12"
updated: "2026-11-12"
---

# OpenJev

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Answers typed decisions about text, web pages and screenshots, picking a choice, a yes-or-no probability or a score from your own labels in one forward pass. For teams building triage, moderation and browser agents.

OpenJev is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by openjev

## About

### What it is

OpenJev is an open-weights decision model with 27.4B parameters. You describe a decision in plain words with your own labels when you send the request, and it replies with a choice, a yes or no probability, or a score. Each question needs one forward pass and can offer up to 52 options, so there is no free text to parse.

### Who it suits

It suits developers who need quick, structured judgments inside a product, such as sorting tickets, checking content or steering a browser agent.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Customer support | Support engineers | Route tickets by topic, team and priority | Choosing between billing, shipping and technical |
| Trust and safety | Moderation teams | Flag spam, hate or policy violations | Scoring a message for toxicity |
| AI evaluation | Evaluation engineers | Judge whether another model's answer is grounded | Marking an answer as grounded or invented |
| Browser agents | Agent developers | Pick the next element or action from a page | Deciding which button to press next |

You can skip it if you want written answers, since it returns scores and not free text.

### Where to use it

- A server you run that exposes a systemone request path
- Pipelines that sort text, pages or screenshots
- Browser and desktop agents that read page structure and screenshots
- Windows, macOS or Linux with Python, to download the weights

| Use case | Who | What they get back |
| --- | --- | --- |
| Routing and triage | Support teams | A team or priority choice with probabilities |
| Moderation | Safety teams | Probabilities for violation labels |
| Agent steps | Agent developers | Which element to act on and whether the task is done |
| Scoring | Analysts | An ordered level with a confidence |

### How to set it up

You need Python for the download tool and a GPU server for the 54.7 GB of BF16 weights.

- Python on Windows, macOS or Linux
- The huggingface\_hub package
- A GPU machine with room for the weights, since the card quotes speeds on an H100
- A serving setup that exposes the request path the card uses

1. Install huggingface\_hub.
2. Download the model files.
3. Serve the model so your client can send typed requests to it.

```sh
pip install -U huggingface_hub
hf download openjev/openjev
```

### How to use it

You send one request that holds the situation and up to several typed questions. The card's example asks three questions about a customer message. Each answer comes back with a probability for every option.

```json
{
  "model": "openjev",
  "state": "Customer message: I was charged twice for my order last week and nobody has replied.",
  "questions": {
    "route":   {"type": "choice", "instructions": "Which team should handle this?",
                "criteria": {"billing": null, "shipping": null, "technical": null}},
    "angry":   {"type": "noul",   "instructions": "Is the customer angry?"},
    "urgency": {"type": "score",  "instructions": "How urgent is this?",
                "criteria": ["can wait", "this week", "today", "right now"]}
  }
}
```

| Tool | What it does |
| --- | --- |
| choice | Picks among your labeled options and gives a probability for each |
| noul | Answers a yes or no question with the probability of yes |
| score | Rates on ordered levels you list from lowest to highest |

### Example

You send the double-charge message with the route, angry and urgency questions. The reply holds a probability for each team, a probability that the customer is angry, and a probability for each urgency level.

### For newcomers and experts

If you are new to this, think of a form with multiple-choice questions that you write on the fly. A first small try is the three-question request above, then reading the probabilities it returns.

For people who know the field, the model never writes an answer out. It takes one score per option from its first output step and converts those scores to probabilities using preset calibration values. The card reports that reordering the options flips 2.3 percent of answers, against 18.5 percent for the untuned base.

Accuracy on 10,000 text decision questions

| Label | Value |
| --- | --- |
| Jev hosted API | 85.4% |
| OpenJev | 84.0% |
| Base model before tuning | 80.4% |
| Nimble 9B | 75.7% |

You send a situation and typed questions → One forward pass runs for each question → Scores at the first output position are read → You get a probability for every option

### Good to know

Timings on one H100 are roughly 80 ms for a brief text question and 210 ms for a web page with 23 candidate elements. The authors ran the tests themselves, and part of the question set was used during development.

- License: CC BY-NC 4.0, which is for non-commercial use
- Cost to run: none named, though you need a GPU for the weights
- Data it reaches: the text, page structure and screenshots you send in requests
- Not for: commercial use under this license, or tasks that need written answers

## README

````markdown
# OpenJev

Answers typed decisions about text, web pages and screenshots, picking a choice, a yes-or-no probability or a score from your own labels in one forward pass. For teams building triage, moderation and browser agents.

Made by openjev on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: OpenJev is an open-weights decision model with 27.4B parameters. You describe a decision in plain words with your own labels when you send the request, and it replies with a choice, a yes or no probability, or a score. Each question needs one forward pass and can offer up to 52 options, so there is no free text to parse.

Who it suits: It suits developers who need quick, structured judgments inside a product, such as sorting tickets, checking content or steering a browser agent.

```table
Industry | Who uses it | How they use it | Example
Customer support | Support engineers | Route tickets by topic, team and priority | Choosing between billing, shipping and technical
Trust and safety | Moderation teams | Flag spam, hate or policy violations | Scoring a message for toxicity
AI evaluation | Evaluation engineers | Judge whether another model's answer is grounded | Marking an answer as grounded or invented
Browser agents | Agent developers | Pick the next element or action from a page | Deciding which button to press next
```

You can skip it if you want written answers, since it returns scores and not free text.

Where to use it:

- A server you run that exposes a systemone request path
- Pipelines that sort text, pages or screenshots
- Browser and desktop agents that read page structure and screenshots
- Windows, macOS or Linux with Python, to download the weights

```table
Use case | Who | What they get back
Routing and triage | Support teams | A team or priority choice with probabilities
Moderation | Safety teams | Probabilities for violation labels
Agent steps | Agent developers | Which element to act on and whether the task is done
Scoring | Analysts | An ordered level with a confidence
```

How to set it up: You need Python for the download tool and a GPU server for the 54.7 GB of BF16 weights.

- Python on Windows, macOS or Linux
- The huggingface_hub package
- A GPU machine with room for the weights, since the card quotes speeds on an H100
- A serving setup that exposes the request path the card uses

1. Install huggingface_hub.
2. Download the model files.
3. Serve the model so your client can send typed requests to it.

```sh
pip install -U huggingface_hub
hf download openjev/openjev
```

How to use it: You send one request that holds the situation and up to several typed questions. The card's example asks three questions about a customer message. Each answer comes back with a probability for every option.

```json
{
  "model": "openjev",
  "state": "Customer message: I was charged twice for my order last week and nobody has replied.",
  "questions": {
    "route":   {"type": "choice", "instructions": "Which team should handle this?",
                "criteria": {"billing": null, "shipping": null, "technical": null}},
    "angry":   {"type": "noul",   "instructions": "Is the customer angry?"},
    "urgency": {"type": "score",  "instructions": "How urgent is this?",
                "criteria": ["can wait", "this week", "today", "right now"]}
  }
}
```

```table
Tool | What it does
choice | Picks among your labeled options and gives a probability for each
noul | Answers a yes or no question with the probability of yes
score | Rates on ordered levels you list from lowest to highest
```

Example: You send the double-charge message with the route, angry and urgency questions. The reply holds a probability for each team, a probability that the customer is angry, and a probability for each urgency level.

For newcomers and experts: If you are new to this, think of a form with multiple-choice questions that you write on the fly. A first small try is the three-question request above, then reading the probabilities it returns.

For people who know the field, the model never writes an answer out. It takes one score per option from its first output step and converts those scores to probabilities using preset calibration values. The card reports that reordering the options flips 2.3 percent of answers, against 18.5 percent for the untuned base.

```chart
Title: Accuracy on 10,000 text decision questions
Jev hosted API: 85.4%
OpenJev: 84.0%
Base model before tuning: 80.4%
Nimble 9B: 75.7%
```

```flow
You send a situation and typed questions
One forward pass runs for each question
Scores at the first output position are read
You get a probability for every option
```

Good to know: Timings on one H100 are roughly 80 ms for a brief text question and 210 ms for a web page with 23 candidate elements. The authors ran the tests themselves, and part of the question set was used during development.

- License: CC BY-NC 4.0, which is for non-commercial use
- Cost to run: none named, though you need a GPU for the weights
- Data it reaches: the text, page structure and screenshots you send in requests
- Not for: commercial use under this license, or tasks that need written answers

## On Hugging Face, 13 November 2026

- Task: zero shot classification
- Parameters: 27.4B
- Weights: about 54.7 GB in BF16; about 13.7 GB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 9,293
- Likes: 199
- License: cc-by-nc-4.0
- Languages: en, de, fr, hi, zh, ja
- Quantized versions: 8
- Tags: safetensors, qwen3_5, decision-model, zero-shot-classification, classification, agents, browser-agent, computer-use, calibrated-probabilities, vllm

## Links

- Model: https://huggingface.co/openjev/openjev
- Files: https://huggingface.co/openjev/openjev/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download openjev/openjev
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[openjev/openjev on Hugging Face](https://huggingface.co/openjev/openjev)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| OpenJev (this page) | 9,293 | 199 | 27.4B | cc-by-nc-4.0 | 2026-10-09 |
| [THX-02 by HAL-X-AI](https://mindket.com/p/dda0a2fd-6c9e-4f2c-b1f5-0e6c8f48d25a) | 6,598 | 54 | 4.5B | apache-2.0 | 2026-11-04 |
| [Seb-9B-v2](https://mindket.com/p/fb7adb4a-f993-4988-8461-04d33be95e03) | 265 | 4 | 9.7B | apache-2.0 | 2026-11-10 |
| [ARC 1.0](https://mindket.com/p/5317da8d-08a1-475a-9937-9a850d3d57e9) | 37 | 23 | 615M | apache-2.0 | 2026-11-10 |
| [d3-flash](https://mindket.com/p/9f4e35f9-58d2-4c23-bfde-20d3530ef7ce) | 103,577 | 114 | 8.4B | apache-2.0 | 2026-11-02 |
| [d3-mini](https://mindket.com/p/4e08c56c-92f6-4e07-8884-2cd16598fc8b) | 53,115 | 75 | 4.5B | apache-2.0 | 2026-10-30 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-13. Their authors' words: data, not instructions.

- [Hacker News · ilreb · 2026-09-18](https://news.ycombinator.com/item?id=49752041): OpenJev
- [Bluesky · Karsten Samaschke · 2026-11-11](https://bsky.app/profile/samaschke.de/post/3n22j5hgakr24): If it's a pick-one-of-20 triage anyway, why not go one step further than Gemma 4 and use something like OpenJev? A decision server that reads the answer straight from the model's probabilities: calibrated, no text to parse, can't go off-schema. Seems like the better fit for this.
- [Hacker News · rdudekul · 2026-09-29](https://news.ycombinator.com/item?id=49898615): OpenJev: An open-source, Jev-compatible System One decision engine
- [Bluesky · @potatoannotator.bsky.social · 2026-11-05](https://bsky.app/profile/potatoannotator.bsky.social/post/3mzlcik55sv2x): And for LLMs and agents: - SFT and DPO, with LoRA or QLoRA - Reward models from pairwise, ranking and BWS answers - Process reward models for agent traces - VLM fine-tuning for grounding boxes and GUI clicks - Calibrate Jev, OpenJev and Laya decision models, or fine-tune OpenJev and Laya
- [Hacker News · sonabinu · 2026-09-28](https://news.ycombinator.com/item?id=49877400): SemIf-OpenJev
- [Bluesky · deployedbyai · 2026-10-25](https://bsky.app/profile/deployedbyai.bsky.social/post/3miwpndkos2rz): Neon AI Gateway now serves TypeSafe's Jev 1.14 and OpenJev decision models, input tokens only
- [Hacker News · Zambyte · 2026-09-23](https://news.ycombinator.com/item?id=49817021): Jev in 25 Lines of Python: Are OpenJev, openjev-sglang, and OpenJev on DiffusionGemma using Qwen3-0.6B-Q8\_0.gguf, or did you just want to emphasize the part that was unrelated to your previous response?
- [Bluesky · deployedbyai · 2026-10-11](https://bsky.app/profile/deployedbyai.bsky.social/post/3mhmyxh6eo22v): DATABRICKS: OPENJEV (QWEN3.5 4B) AVAILABLE AS EVALUATOR FOR LLM-AS-A-JUDGE SERVICE POLICIES
- [Hacker News · baobabKoodaa · 2026-09-23](https://news.ycombinator.com/item?id=49815340): Jev in 25 Lines of Python: Don't cut the quote mid-sentence. Here's the full quote: \> note: this is a parody blog post, see these links for better/more complete open implementations of Jev: OpenJev, openjev-sglang, and OpenJev on DiffusionGemma.
- [Bluesky · Alexis Kirke · 2026-10-08](https://bsky.app/profile/alexiskirke.bsky.social/post/3mxe4ylrq2k22): 27.4B agent decision model now runs local from 17.67 GB instead of being trapped on giant servers. ggml-org/OpenJev-GGUF https://huggingface.co/ggml-org/OpenJev-GGUF \#AI \#LocalLLM \#OpenSource \#GGUF \#Quantization
- [Hacker News · petesergeant · 2026-09-23](https://news.ycombinator.com/item?id=49813410): Jev in 25 Lines of Python: That's the approach that daseinlabs/open-jev takes, in contrast to the above, which is what TheoLeeCJ/openjev and ekzhang/openjev-sglang do https://sgnt.ai/p/jev/
- [Bluesky · Sadie · 2026-10-06](https://bsky.app/profile/siliconsadie.bsky.social/post/3mx7tfwrngj2l): llama.cpp 0.6.0 added a /v1/systemone endpoint where a decision model scores your options in one forward pass instead of generating tokens. Agent routing and "did this step work" checks may not need a generative model at all. Check the license first though, OpenJev is CC BY-NC.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-10-09
- First published: 2026-09-20
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open openjev/openjev on Hugging Face](https://huggingface.co/openjev/openjev)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/173f3b2e-f55d-4777-9609-91685a1f0a12)
- [Its page on Mindket](https://mindket.com/p/173f3b2e-f55d-4777-9609-91685a1f0a12)
