---
title: "OneJev1.6-27B"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/cf8a383c-4770-4ae2-b940-4df48666dae9"
updated: "2026-11-13"
---

# OneJev1.6-27B

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

Reads a screenshot, photo, video or text plus your typed questions and returns a probability for each answer option, such as what an agent should do next or whether a task is done.

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

Made by OmniJev

## About

### What it is

OneJev1.6-27B is a 27B-parameter model that reads a screenshot, photo, video or plain text together with a few typed questions. For every answer option it returns a probability, all in one forward pass.

It was trained from Qwen3.8-27B with every weight updated, using about 440,000 questions from actual agent runs, videos, images and the training parts of public decision datasets.

### Who it suits

Developers building agents that act on a screen will get the most from it, along with testers and researchers who want numbers instead of free text. You write yes-or-no, multiple-choice or rating questions and read the probabilities back.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Software | Agent developers | Pick the next action of an agent from a screenshot | Choose between click, type, scroll and stop |
| Quality assurance | Test engineers | Check that a task reached its goal | Ask whether an invoice has been paid |
| Operations | Automation teams | Rate how far a workflow has come | Score progress from not started to done |
| Research | Machine learning researchers | Test the decision quality of a 27B open model | Compare its scores with the base model |

People who want long free-form replies can skip it, since it is built to score options you list.

### Where to use it

- Your own computer: the file download works on Windows, macOS and Linux, and the quick start uses a bash-style shell with uv
- Agent code that sends requests to the local server and reads the probabilities
- The Hugging Face transformers library, which the model page lists
- A machine with room for about 54.7 GB of BF16 weights, or about 13.7 GB at 4-bit by estimate

| Use case | Who | What they get back |
| --- | --- | --- |
| Decide the next agent step | Agent developers | One probability for click, type, scroll and stop |
| Check that a task is done | Testers | The probability of yes for a condition you write |
| Track progress | Automation teams | An expected level from a list of levels you give |

### How to set it up

You need a few things in place before the first run.

- Python 3.12 and the uv tool
- A bash-style shell, since the quick start activates the environment with source
- Memory for the weights: about 54.7 GB in BF16, or about 13.7 GB at 4-bit as an estimate
- A screenshot file, such as screenshot.png, for the example request

1. Create a Python 3.12 environment with uv and activate it.
2. Install Flide and torchvision into that environment.
3. Start the Flide server with this model.
4. If you only want the files, install huggingface\_hub and run its download command instead.

```bash
uv venv -p 3.12 && source .venv/bin/activate
uv pip install flide torchvision
flide serve --model OmniJev/OneJev1.6-27B
```

```bash
pip install -U huggingface_hub
hf download OmniJev/OneJev1.6-27B
```

### How to use it

With the server running, open a second terminal and send it a JSON request. The request holds a state with your task and screen, a media list with each image as base64 data, and your questions. The source posts it with curl to the v1/systemone path on port 8000 of your own machine.

```json
{
  "state": {"task": "Pay the open invoice from ACME", "screen": "<image:1>"},
  "media": [{"type": "image", "data": "data:image/png;base64,$IMG"}],
  "questions": {
    "done": {"type": "noul", "instructions": "The invoice has been paid"},
    "next": {"type": "choice", "instructions": "What should the agent do next?",
             "criteria": {"click": "click an element", "type": "type text", "scroll": "scroll", "stop": "stop"}},
    "progress": {"type": "score", "instructions": "How far along is the task?",
                 "criteria": ["not started", "halfway", "almost done", "done"]}
  }
}
```

The reply carries answers.done.noul, answers.next.probabilities and answers.progress.score. Each question has one of three types.

| Tool | What it does |
| --- | --- |
| noul | Returns the probability of yes for a statement you write |
| choice | Returns one probability for each option you list |
| score | Returns the expected level from an ordered list of levels |

### Example

You send a screenshot with the task "Pay the open invoice from ACME" and three questions. Has the invoice been paid, what should the agent do next, and how far along is the task. Back come the probability of yes for the first, one probability for each of click, type, scroll and stop, and an expected progress level.

### For newcomers and experts

Think of it as a judge, not a writer. You show it a screen and ask a few questions with fixed answers, and it tells you how likely each answer is. A good first try is to start the server and send the sample request with your own screenshot.

Underneath, it is a Qwen3.8-27B base with all weights tuned for System One decisions. Instead of writing text, it scores the options you define in a single forward pass. The Flide server around it exposes the System One interface and takes images and video through an extra media field. The trade-off is that it only answers questions you frame as options. Decision Index 0.3 gives it 69.49 on the public part of the board, against 63.64 for OneJev1.5-27B.

Send a screenshot, photo, video or text → Add typed questions with their options → The model reads everything in one pass → The server returns a probability per option

### Good to know

The scores below are the author's own report from a public benchmark board, so test the model on your own screens before you rely on it.

Decision Index 0.3 public score

| Label | Value |
| --- | --- |
| OneJev1.6-27B | 69.49 points |
| OneJev1.5-27B | 63.64 points |

- Size: 27.4B parameters stored as Safetensors, and the page lists one quantized copy made by someone else
- Base: it builds on Qwen3.8-27B
- License: Apache 2.0
- Cost to run: no API key or paid service is named, but you need hardware for the weights listed above
- Data it reaches: the screenshots, photos, videos and text you put in a request, which the example sends to a server on your own machine
- Not for: the source lists no restrictions beyond its license

## README

````markdown
# OneJev1.6-27B

Reads a screenshot, photo, video or text plus your typed questions and returns a probability for each answer option, such as what an agent should do next or whether a task is done.

Made by OmniJev 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: OneJev1.6-27B is a 27B-parameter model that reads a screenshot, photo, video or plain text together with a few typed questions. For every answer option it returns a probability, all in one forward pass.

It was trained from Qwen3.8-27B with every weight updated, using about 440,000 questions from actual agent runs, videos, images and the training parts of public decision datasets.

Who it suits: Developers building agents that act on a screen will get the most from it, along with testers and researchers who want numbers instead of free text. You write yes-or-no, multiple-choice or rating questions and read the probabilities back.

```table
Industry | Who uses it | How they use it | Example
Software | Agent developers | Pick the next action of an agent from a screenshot | Choose between click, type, scroll and stop
Quality assurance | Test engineers | Check that a task reached its goal | Ask whether an invoice has been paid
Operations | Automation teams | Rate how far a workflow has come | Score progress from not started to done
Research | Machine learning researchers | Test the decision quality of a 27B open model | Compare its scores with the base model
```

People who want long free-form replies can skip it, since it is built to score options you list.

Where to use it:

- Your own computer: the file download works on Windows, macOS and Linux, and the quick start uses a bash-style shell with uv
- Agent code that sends requests to the local server and reads the probabilities
- The Hugging Face transformers library, which the model page lists
- A machine with room for about 54.7 GB of BF16 weights, or about 13.7 GB at 4-bit by estimate

```table
Use case | Who | What they get back
Decide the next agent step | Agent developers | One probability for click, type, scroll and stop
Check that a task is done | Testers | The probability of yes for a condition you write
Track progress | Automation teams | An expected level from a list of levels you give
```

How to set it up: You need a few things in place before the first run.

- Python 3.12 and the uv tool
- A bash-style shell, since the quick start activates the environment with source
- Memory for the weights: about 54.7 GB in BF16, or about 13.7 GB at 4-bit as an estimate
- A screenshot file, such as screenshot.png, for the example request

1. Create a Python 3.12 environment with uv and activate it.
2. Install Flide and torchvision into that environment.
3. Start the Flide server with this model.
4. If you only want the files, install huggingface_hub and run its download command instead.

```bash
uv venv -p 3.12 && source .venv/bin/activate
uv pip install flide torchvision
flide serve --model OmniJev/OneJev1.6-27B
```

```bash
pip install -U huggingface_hub
hf download OmniJev/OneJev1.6-27B
```

How to use it: With the server running, open a second terminal and send it a JSON request. The request holds a state with your task and screen, a media list with each image as base64 data, and your questions. The source posts it with curl to the v1/systemone path on port 8000 of your own machine.

```json
{
  "state": {"task": "Pay the open invoice from ACME", "screen": "<image:1>"},
  "media": [{"type": "image", "data": "data:image/png;base64,$IMG"}],
  "questions": {
    "done": {"type": "noul", "instructions": "The invoice has been paid"},
    "next": {"type": "choice", "instructions": "What should the agent do next?",
             "criteria": {"click": "click an element", "type": "type text", "scroll": "scroll", "stop": "stop"}},
    "progress": {"type": "score", "instructions": "How far along is the task?",
                 "criteria": ["not started", "halfway", "almost done", "done"]}
  }
}
```

The reply carries answers.done.noul, answers.next.probabilities and answers.progress.score. Each question has one of three types.

```table
Tool | What it does
noul | Returns the probability of yes for a statement you write
choice | Returns one probability for each option you list
score | Returns the expected level from an ordered list of levels
```

Example: You send a screenshot with the task "Pay the open invoice from ACME" and three questions. Has the invoice been paid, what should the agent do next, and how far along is the task. Back come the probability of yes for the first, one probability for each of click, type, scroll and stop, and an expected progress level.

For newcomers and experts: Think of it as a judge, not a writer. You show it a screen and ask a few questions with fixed answers, and it tells you how likely each answer is. A good first try is to start the server and send the sample request with your own screenshot.

Underneath, it is a Qwen3.8-27B base with all weights tuned for System One decisions. Instead of writing text, it scores the options you define in a single forward pass. The Flide server around it exposes the System One interface and takes images and video through an extra media field. The trade-off is that it only answers questions you frame as options. Decision Index 0.3 gives it 69.49 on the public part of the board, against 63.64 for OneJev1.5-27B.

```flow
Send a screenshot, photo, video or text
Add typed questions with their options
The model reads everything in one pass
The server returns a probability per option
```

Good to know: The scores below are the author's own report from a public benchmark board, so test the model on your own screens before you rely on it.

```chart
Title: Decision Index 0.3 public score
OneJev1.6-27B: 69.49 points
OneJev1.5-27B: 63.64 points
```

- Size: 27.4B parameters stored as Safetensors, and the page lists one quantized copy made by someone else
- Base: it builds on Qwen3.8-27B
- License: Apache 2.0
- Cost to run: no API key or paid service is named, but you need hardware for the weights listed above
- Data it reaches: the screenshots, photos, videos and text you put in a request, which the example sends to a server on your own machine
- Not for: the source lists no restrictions beyond its license

## On Hugging Face, 13 November 2026

- Task: image text to text
- Library: transformers
- 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: 528
- Likes: 5
- License: apache-2.0
- Based on: Qwen/Qwen3.8-27B
- Quantized versions: 1
- Tags: transformers, safetensors, qwen3_5, image-text-to-text, onejev, system-one, decision-model, calibration, multimodal, gui-agent, video, conversational

## Links

- Model: https://huggingface.co/OmniJev/OneJev1.6-27B
- Files: https://huggingface.co/OmniJev/OneJev1.6-27B/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download OmniJev/OneJev1.6-27B
```

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

## What is in it

1 files, 7 KB, downloaded as a zip.

```text
README.md  7 KB
```

## Source

[OmniJev/OneJev1.6-27B on Hugging Face](https://huggingface.co/OmniJev/OneJev1.6-27B)

## 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 |
| --- | --- | --- | --- | --- | --- |
| OneJev1.6-27B (this page) | 528 | 5 | 27.4B | apache-2.0 | 2026-11-10 |
| [OneJev1.6-4B](https://mindket.com/p/54898cc3-d040-488d-ae95-b4e9f0e49de4) | 1,909 | 8 | 4.5B | apache-2.0 | 2026-11-10 |
| [OneJev1.6-0.8B](https://mindket.com/p/7b44bdb4-74c1-4e3b-b0c2-32e28fc4663f) | 1,885 | 6 | 853M | apache-2.0 | 2026-11-10 |
| [OneJev1.6-4B-GGUF](https://mindket.com/p/b8361417-2c40-44d7-b244-622b86f6689c) | 4,292 | 2 | 4.2B | apache-2.0 | 2026-10-17 |
| [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.

## 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-11-10
- First published: 2026-10-16
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open OmniJev/OneJev1.6-27B on Hugging Face](https://huggingface.co/OmniJev/OneJev1.6-27B)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/cf8a383c-4770-4ae2-b940-4df48666dae9)
- [Its page on Mindket](https://mindket.com/p/cf8a383c-4770-4ae2-b940-4df48666dae9)
