OpenJev-GGUF 27.4B Decision-Making Specialized Model: 24GB+ VRAM

October 2, 2026

At a Glance

Values determined by this site’s code when the information was collected. Dates are JST.

Overview

ggml-org has released “ggml-org/OpenJev-GGUF", a GGUF quantized version of “OpenJev", an open-weight model specialized in decision-making. This model is designed to accept text, web pages, and screenshots as inputs to perform choice-based decision-making (decision-model). Instead of generating free text and parsing it for user-requested questions in JSON format, it features a mechanism that directly outputs probabilities or scores for each choice in a single forward pass.

Specifications

The specifications of the original model openjev/openjev are as follows:
– Parameters: 27.4B
– Architecture: Qwen3_5ForConditionalGeneration (qwen3_5)
– Context length: Up to 16,384 tokens

Performance

Here are the benchmark results for the original model openjev/openjev published by its creators. Since this is a GGUF quantized version, the following figures are measured values on the unquantized original model.

First, here is a comparison with other models across 10,000 text-based questions (using 34 public sources):

From this table, we can see that OpenJev achieves an accuracy of 84.0%, significantly outperforming the pre-tuning base model (80.4%) and the open model Nimble 9B (75.7%). Meanwhile, while it fell slightly short of the hosted API Jev (hosted API) at 85.4%, it comes very close with a small difference of 1.4 points.

Next is the breakdown of accuracy by category:

Looking at these category results, OpenJev shows high accuracy in tasks such as “intent / routing / topic" (92.8%) and “reading + language" (89.2%). It also scores higher than the hosted API Jev in “ethics / policy judgement" (78.1%) and “sentiment / stance" (82.1%). However, in fields like “science / facts / claims" (82.5%) and “commonsense reasoning" (85.8%), it falls slightly behind the hosted API Jev (89.0% and 88.3% respectively).

Additionally, the comparison results before and after tuning on agent-based decision-making tasks are as follows:

From these results, OpenJev achieves a significant accuracy improvement of over 10 points compared to pre-tuning when determining next actions for desktop operations from screenshots or on unseen websites and domains. Furthermore, answer flips when options are shuffled decreased drastically from 18.5% to 2.3%, demonstrating extremely high stability as a decision-making model.

Comparisons regarding multilingual support and long-context reading comprehension are as follows:

This table indicates that accuracy has improved over pre-tuning in multilingual tasks involving German, French, Hindi, Chinese, and Japanese. On the other hand, in question tasks regarding long articles (QuALITY), the score remains unchanged at 91.7% before and after tuning, maintaining equivalent performance.

Finally, here is the number of completed tasks when executing end-to-end browser tasks (100 types of MiniWoB tasks, 1 trial each):

These results confirm that in end-to-end browser tasks, OpenJev completes 39 tasks, matching the hosted Jev API and showing a slight improvement from the 38 tasks completed before tuning.

Strengths and Use Cases

This model is a “decision model" that accepts text or images (screenshots) as inputs and makes optimal decisions from pre-defined choices. Unlike general chat bots that generate free text before parsing, it calculates probabilities directly from token scores at the initial output position, enabling fast and reliable processing.

Based on the performance and features of the original model openjev/openjev, it is highly suited for the following applications and tasks:

• Routing and Triage:
  Determining the intent, topic, responsible team, priority, or language of user inquiry messages to automatically route them to the appropriate destination.

• Moderation and Safety Judgment:
  Evaluating whether input text falls under harmful content, spam, hate speech, policy violations, or legal threats.

• LLM as a Judge:
  Objectively determining whether a generative AI model’s output is based on reliable evidence (presence of hallucinations), follows provided evaluation criteria (rubrics), or which of multiple answers is superior.

• Business Processes and Document Management:
  Automating routine judgment tasks such as approving, withholding, or rejecting invoices, determining the severity of system alerts, or classifying specific clause types in contracts.

• Browser and Desktop Agents:
  Reading screen screenshots, HTML (DOM structure), or JSON data to determine the next element to interact with or action to execute (such as clicks or input). It can also judge whether a task is complete or blocked.

• Scoring:
  Calculating ordered step-by-step evaluations accompanied by expected values or confidence levels.

Furthermore, because this model allows dynamic specification of choices (labels) per request, task-specific pre-training or fixed labeling is unnecessary. It can process up to 52 choices in a single request during a single forward pass, and can simultaneously handle multiple questions (e.g., routing, sentiment analysis, urgency) in one request. A major strength is its support for multiple languages including Japanese (English, German, French, Hindi, Chinese, and Japanese).

How It Differs from Similar Models

In a previous article introduced on our site, Decision-Making Specialized Model “OpenJev" Testing GGUF Model Released, we covered “tinyopenjev-for-testing-gguf", also released by ggml-org. However, that was an ultra-small test-only model (approx. 34M parameters) created solely to verify whether inference engines and loaders function properly, and its output content carried no meaning.

In contrast, the newly released “OpenJev-GGUF" is a practical quantized model that retains the entire structure of the original model openjev/openjev. Unlike the test model, it can be used directly for actual decision-making tasks and agent inference purposes.

Hardware Requirements

Estimated requirements (calculated by Local Model Watch) — 27.4B parameters (taken from the base model openjev/openjev)

Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.

Can You Run It Locally?

Runs in Ollama, LM Studio and llama.cpp as-is.

It is distributed in GGUF, so no conversion is needed.

License — cc-by-nc-4.0 (Commercial use prohibited): Commercial use is prohibited (NC = NonCommercial). Internal business use can also count as commercial, so avoid this license for work use.

Compression: the Q4_K_M build measures 5.56 bits per weight — about 35% the size of the original 16-bit weights, calculated by this site from the actual file sizes.

Compiled by this site’s code from the published formats, converted builds we have found, and each engine’s own model registry. “Not found" means we have not seen such a build, not that none exists. License summaries are not legal advice — check the publisher’s original terms before relying on them.

Our Own Measurements

Measurements We Did Not Take

This model’s license (cc-by-nc-4.0) does not permit commercial use. Because this site carries advertising, we did not run the model (no CPU run, answers, quantization comparison, conversion or generation).

Recent Models in the Same Size Class

Models with 15–40B parameters that Local Model Watch covered recently, listed by code from our article log for comparison. VRAM tiers are this site’s estimates; licenses are as stated on the model cards.

How to Get It

This model is distributed in GGUF format and can be run using inference engines such as llama.cpp.

When launching, you can use the llama serve command included in llama.cpp to load the model directly from the Hugging Face repository and start a server. Running the following command starts the API server in your local environment:

llama serve -hf ggml-org/OpenJev-GGUF

After startup, you can send decision-making requests via the dedicated API endpoint /v1/systemone.

Note that the weights of this model are released under the “CC BY-NC 4.0" license. While it is free for non-commercial research and use, acquiring a separate commercial license is required for commercial use.

Related Articles

• Testing OpenJev GGUF: A Tiny Model for Runtime Loaders
• MiMo-V2.6-Flash-RL-GGUF Multimodal MoE Model: ~141GB Memory
• MiMo-V2.6-Distill-Qwen-9B-GGUF: Our Test Answers, 12GB+ VRAM
• ggml v0.24.0 Released with Backend Improvements and API Updates

What to Read Next

• Find models by VRAM (This model runs from the 24GB tier) → Other models that run on a 24GB GPU
• Engines that run this model → llama.cpp / Ollama
• What Q4_K_M, Q8_0 mean and where to get this model → GGUF format guide and models / Quantization and model-format glossary
• Other models for the same task → Other vision-language models

Sources

• https://huggingface.co/ggml-org/OpenJev-GGUF
• https://huggingface.co/openjev/openjev