mohit67890/imajev

Small open models (2B · 4B · 9B) that read the photos, records and text a business already has and answer in the options you set,
with a probability on each and an explicit can't tell. Your system acts when it is sure and hands the rest to a person.

Live demo · Website · Quickstart · Checked examples · Results · Technical report

Screenshots of the official leaderboards, captured 28 Sep 2026. Each board is run by its own maintainer, not by us; click through for the live page.

Scored 27 Sep 2026. imajev-4b 67.37, ahead of Plumb-4B (65.84) and TypeSafe's own Jev 1.13.0 (63.29).

Released 28 Sep 2026. imajev-4b 76.39, ahead of Jev-Omni (12B, 73.10) and NeoHorse Jev 4B (71.94); imajev-2b is #6. Sealed accuracy 83.3%, second of 44 self-hosted systems. Measured by the maintainer on the fast server (--fast --merge-lora, one option order, shipped calibration).

"Imajev-4B leads the Jev-class systems with 66.3" (Capability: intelligence and calibration, among systems within 2× Jev's cost and latency).

79.65, ahead of GLM-5.3 Flash (320B), Jev 1.13, DeepSeek V4.1 Flash (552B) and GPT-5.6 Luna. The two above are the benchmark team's own Bosun models.

80.58, behind GLM-5.3 Flash and GPT-5.6 Luna, ahead of DeepSeek V4.1 Flash (552B) and Jev 1.13.

_{Boards move as new systems are added; ranks are quoted with the board version and the date. Archived copies and the raw data are linked in Official leaderboards.}

The live demo runs imajev-4b on a GPU. Pick one of the checked examples (a listing against its photo, a return, a part on the line, an email against a CRM record, a refund against the policy, a ticket, a stylist request it declines to guess on), change the record or swap a photo, and watch the answer and the app's action change. Or upload your own photo and write your own questions.

Send the evidence and the questions you care about. Each answer comes back as a probability over the answers you allowed, ready for an if. This is the exact script we ran against imajev-4b (site/showcase/listing.py) and its output, with numbers rounded to three places and usage shortened; 1.15 s on a Mac Studio (four option orders averaged, calibration file applied).

import json, requests

URL = "http://127.0.0.1:8765/v1/systemone"

listing = {
    "title": "Men's suede boat shoes",
    "color": "red",
    "product_type": "shoe",
}

questions = {
    "contradicted_field": {
        "type": "choice",
        "instructions":
            "Which field of `listing` does this photo contradict?",
        "criteria": {
            "listing.color": None,
            "listing.product_type": None,
            "none of these": "the photo agrees with every field",
        },
    },
    "color_matches": {
        "type": "noul",
        "instructions":
            "The product in the photo matches `listing.color`.",
    },
    "type_matches": {
        "type": "noul",
        "instructions": "The photo shows the kind of product "
                        "given in `listing.product_type`.",
    },
}

request = {"state": {"listing": listing}, "questions": questions}
with open("listing.jpg", "rb") as photo:
    r = requests.post(URL, files={"image": photo},
                      data={"request": json.dumps(request)})
print(json.dumps(r.json(), indent=2))

{
  "model": "imajev-4b",
  "answers": {
    "contradicted_field": {
      "type": "choice",
      "choice": "listing.color",
      "probabilities": {
        "listing.color": 0.95,
        "listing.product_type": 0.006,
        "none of these": 0.043
      },
      "confidence": 0.919,
      "unknown_probability": 0.007,
      "abstained": false
    },
    "color_matches": {
      "type": "noul",
      "noul": 0.082,
      "unknown_probability": 0.022,
      "abstained": false
    },
    "type_matches": {
      "type": "noul",
      "noul": 0.989,
      "unknown_probability": 0.004,
      "abstained": false
    }
  },
  "usage": {
    "total_ms": 1152.9,
    "input_tokens": 224
  }
}

_{The same endpoint with no photo: one request routes the ticket (choice), flags urgency (yes/no) and scores frustration (score). Script: site/showcase/ticket.py.}

Jev reads text only. General vision models answer in prose, from a hosted API, in seconds. imajev brings Jev's typed answers to photos, and runs on your own hardware.

• A photo read against your record. Checks a photo against the fields in your own data and names the field that is wrong. Trained on 72k photo-vs-record and two-photo decisions.
• Two photos, one decision. A reference and a target in one request: what was shipped against what came back, a known-good part against the one on the line.
• A trained can't tell. Every answer carries a probability for unknown. Asked for a white or beige bag from a closet with only a red and a black backpack, the 4B puts 0.89 on unknown instead of guessing.
• Open, small and local. Apache-2.0 weights from 2B. A Mac or one GPU, about 0.1 s per question raw, about 0.3 s as shipped (four option orders averaged); photos and customer data never leave your network.
• Jev's contract, now with images. The same request and response as TypeSafe's Jev, plus images, unknown_probability and abstained. Text-only Jev requests work unchanged.

_{Jev from docs.typesafe.ai (models page, Jev 1.13.0). Jev-Omni from its model card and our run of its own predict() API. Frontier rows and all ImajevBench numbers from our runs, 24 Sept 2026; frontier models answer by structured generation, a different interface. Jev's record limit is larger than imajev's.}

The decisions it handles well are the high-volume, well-defined ones with a clear set of answers.

You choose how sure the model must be before it acts. A higher bar automates less and makes fewer mistakes; everything below it goes to a person, including when it says it can't tell.

_{The 279 ImajevBench test questions (photos, records and text; 21 whose honest answer is can't tell), raw probabilities, scored with the benchmark's own rule (as shipped: four option orders, calibration file). The benchmark is built to be hard, so treat these as a starting point and measure on a few hundred of your own cases before choosing.}

Every example comes from one of five small apps in scripts/playground/. Every combination a visitor can click in them is sent to the model and compared with the right answer (node scripts/playground/verify_scenarios.mjs); a check passes when the answer is right and the app takes the expected action at an 80% threshold. imajev-4b, served without its calibration file (four option orders):

App		What it asks	Passed	With the calibration file
	Business checks	Does the photo match the listing? Is the return the item we shipped? Is this part chipped?	19 / 21	19 / 21
	Text only	An email against a CRM record, a refund against the policy, a post against forum rules, a review, an inbox. Written for the launch and run once.	20 / 21	18 / 21
	Wardrobe	Is this what I ordered, does it meet the dress code, do I already own it, which shoes match?	48 / 49	38 / 49
	Stylist app	Reads a piece of clothing, then picks bottoms, shoes and a bag from your closet in your colours.	21 / 24	21 / 24
	Tracing pad	Reads which letter or number a child traced; the app checks the strokes covered every line.	22 / 30	22 / 30
	All		129 / 145	113 / 145

With the calibration file the top answer never changes, but confidence is lower, so more cases go to a person at 80%. The misses worth knowing: with a blank payment note the 4B answered "not paid" instead of unknown, and it reads 8 of 10 scribbles on the tracing pad as letters. Every run, pass or miss, is in results/scenarios/.

2026-09-26: the 4B moved to its phase-3 adapter (rank-64 LoRA, 256-code readout, trained on the decisions the previous release got wrong): ImajevBench 82.4 → 83.9%, hidden split 84.2 → 85.6%, JevBench hard as shipped 70.3 → 72.1%, DecisionBench full suite 77.5 → 79.7%; it abstains on 18 of 21 ImajevBench Unknown items (was 14) and on 9 of 258 answerable ones (was 3). Its calibration on DecisionBench is worse than before (ECE 0.024 → 0.069). The 2B and 9B are unchanged. Details: results/phase3/benchmarks.md.

Start with the 4B. On ImajevBench it is ahead of the 9B (83.9% vs 82.1%; not significant, paired test p = 0.57) and one point ahead of it on JevBench hard. The 2B is 11 points lower on ImajevBench and 10 lower on JevBench hard; pick it when its footprint is the point. The Mac (MLX) weights agree with the GPU run on 97 to 99% of ImajevBench answers (2B 97.1%, 4B 98.2%, 9B 99.3%).

git clone https://github.com/mohit67890/imajev && cd imajev
python3.11 -m venv .venv && source .venv/bin/activate
pip install -e ".[serve,mlx]"          # Apple silicon;  elsewhere: pip install -e ".[serve,torch]"
python scripts/download_model.py --model 4b          # pinned Qwen3.5-4B into .cache/
hf download mohit67890/imajev-4b --local-dir adapters/imajev-4b
PYTHONPATH=src:scripts python scripts/playground/server.py --model-bundle artifacts/model-qwen4b.json \
  --adapter adapters/imajev-4b/mlx --calibration adapters/imajev-4b/calibration.json --model-name imajev-4b --port 8765

Open http://127.0.0.1:8765/ for the playground, or call the API:

curl -s http://127.0.0.1:8765/v1/systemone \
  -F 'request={"state":{"listing":{"title":"Blue ceramic mug, 350 ml","colour":"blue"}},
               "questions":{"matches":{"type":"noul","instructions":"Does the photo show the listed item?"},
                            "wrong_field":{"type":"choice","instructions":"Which listing field does the photo contradict?",
                                           "criteria":{"title":null,"colour":null,"none":null}}}}' \
  -F image=@photo.jpg

import requests
r = requests.post("http://127.0.0.1:8765/v1/systemone", json={
    "state": "Ticket: 'Charged twice for one order, need the duplicate refunded.'",
    "questions": {"queue": {"type": "choice", "instructions": "Route the ticket.",
                            "criteria": {"billing": None, "shipping": None, "account": None, "other": None}},
                  "urgency": {"type": "score", "instructions": "How urgent is this ticket?",
                              "criteria": ["can wait a week", "this week", "today", "within the hour", "right now"]}}})
print(r.json()["answers"]["queue"])   # {"type": "choice", "choice": "billing", "probabilities": {...}, "confidence": ..., "unknown_probability": ..., "abstained": false}

On Linux / CUDA, add --backend torch and pass --adapter adapters/imajev-4b (the PEFT adapter at the repo root). For the other sizes, swap 4b for 2b or 9b in the download commands, the bundle (artifacts/model-qwen9b.json for the 9B; the 2B is the default bundle) and the adapter paths. --rotations 4 averages four option orders; every number in this README was measured with it and with --calibration (on JevBench hard it adds +1.8 / +0.9 / +0.0 points for the 2B / 4B / 9B at about 3× the latency). The 9B needs ~19 GB resident; do not keep it and another model loaded on the same Mac.

For text-only PyTorch serving without torchvision, install the torch-text extra and use the same downloaded checkpoint and PEFT adapter:

pip install -e ".[serve,torch-text]"
python scripts/playground/server.py --backend torch --model-bundle artifacts/model-qwen4b.json \
  --adapter adapters/imajev-4b --calibration adapters/imajev-4b/calibration.json --model-name imajev-4b --port 8765

Send JSON requests with state and questions, as above, and omit images. Text requests load only the tokenizer; the multimodal processor loads when an image is requested. Image serving requires the existing .[serve,torch] extra, including torchvision. This uses the same Qwen model and decision head; CPU serving still loads the full checkpoint.

On Windows on ARM, PyPI has no torch wheel, so install from PyTorch's CPU index (tested on a Snapdragon X Elite):

uv pip install --index-url https://download.pytorch.org/whl/cpu --extra-index-url https://pypi.org/simple \
  --index-strategy unsafe-best-match -e ".[serve,torch-text]"

On a CUDA GPU, --fast makes the torch backend quicker without changing what it computes: one tokenization per question, image normalisation on the GPU (pixels bit-identical to the processor's), and CUDA graphs of the language model recorded at load (about a minute; needs a C compiler for the Triton kernels, e.g. build-essential). --merge-lora also folds the adapter into the weights at load (float32 sum, rounded once to bf16). Checked against a float32 reference on JevBench public and 300 ImajevBench images: --fast --merge-lora is as close to it as the default path, at 11 ms instead of 59 ms per standard text decision and 91 ms instead of 149 ms per image decision on one H100 (results/serving/fast-path-2026-09-27, scripts/bench_fast_path.py).

What comes back. For each question: choice / score return probabilities over your options (summing to 1, given that the model answers); noul returns P(yes) with half of the unknown mass added, as in Jev. Every answer also has unknown_probability (mass on the trained unknown: missing, contradictory or out-of-scope evidence), abstained (unknown was the most likely outcome) and confidence. Limits per request: up to 2 images, a state up to 32 KB, 1 to 8 questions, 2 to 254 options, 2 to 10 score levels.

Acting on it. Act above a threshold you choose from your own error costs; send abstentions and low-confidence answers to a person.

a = response["answers"]["contradicted_field"]
p = a["probabilities"][a["choice"]] * (1 - a["unknown_probability"])
if a["abstained"] or p < 0.85:
    route_to_person(a)            # the model cannot tell, or is not sure enough
elif a["choice"] == "none of these":
    publish()
else:
    hold(field=a["choice"])

Choosing a size. Start with imajev-4b. Use the 2B when latency or memory is tight (it abstains less often than it should on unknown items); use the 9B for knowledge-heavy text questions when ~19 GB of weights is fine.

Checking it on your data. Score a few hundred of your own labelled requests (include "cannot tell" cases) before trusting a threshold. To fit your own temperature, the evaluators in scripts/ write one JSONL row per question with its logits, and scripts/v1_text/fit_temperature_calibration.py rows.jsonl calibration.json fits one temperature per question type and option count; serve it with --calibration. The full guide is section 5 of the technical report.

Measured by each benchmark's maintainer, not by us. Boards move; every rank is quoted with its version and date.

Official JevBench setup: adapter mohit67890/imajev-4b at revision c9e5f132, this repository at a0134749, served with --rotations 1 --calibration calibration.json (one option order, the shipped calibration file).

The numbers below are from our own runs on 2026-09-24 onward with the released adapters; the raw outputs and per-panel reports are in results/. JevBench is a text-only benchmark; these are its public splits (111 hard / 72 original / 48 easy) run with the jevbench harness and the typesafe adapter on one H100, as shipped (four option orders averaged, calibration file applied) unless stated; the pod was busy with other runs, so latencies are under load. They are not the official board, which adds sealed items and scores four axes (above).

Reading:

• #1 on the official JevBench Score, not on every split. On the public hard split alone, JevK5 and Eikos-4B are ahead of every imajev size, by 2 to 4 items of 111; the 4B is above Hopper (72.1 vs 67.6). The gap to JevK5 is concentrated in judge-style items (previous 4B adapter: 10/17 vs JevK5 13/17 on judge_hard). A frozen Qwen3.6-35B-A3B with thinking scores 97.3% on hard, through a different interface: seconds and thousands of tokens per decision.
• The image gain is on ImajevBench. The paired tests were re-run on the shipped adapters (paired cluster sign-flip over 89 evidence clusters). The 4B beats its untuned base by +13.3 points [+7.5, +19.1], p = 0.0001 (exploratory). The 2B beats its base by +11.5 [+3.5, +18.9], p = 0.005 (our pre-registered test against the untuned base model). The 9B's gain over its base, +5.4 [−1.2, +12.4], p = 0.131, is not significant at 0.05 (same pre-registered test; the previous 9B gave +6.1, p = 0.074, and the earlier version of imajev-9b the test was registered with gave +4.3, p = 0.031). Frontier APIs score 91.4–99.6% by structured generation, a different interface ranked separately. 51 contrast sets pair a scene with an edited copy whose right answer must change, become unknown, or stay; the 4B gets all of a set right in 36 of 51 (9B 35, 2B 25).
• Other open image-capable Jev-class models. Jev-Omni (akhilaaa3/Jev-Omni, Gemma 4 12B) scores 78.5% on the same test through its own predict() API. The 4B/9B lead of about 4 points is not significant (p ≈ 0.25; previous adapters vs Jev-Omni) and comes from abstaining on Unknown items, which Jev-Omni has no output for; on answerable items Jev-Omni is slightly ahead (219 vs 215 / 216 for the previous adapters) and better calibrated (ECE 0.069). Details in bench/LEADERBOARD.md.

• Readout, not generation. Each option is bound to one of 255 single-token codes. The prompt renders the state, the images and the question with its option list, then a decision position; the logits of the option codes (plus the unknown code) at that position are the decision, read through a float32 head. One prefill per request, one forward pass per question, no decoding.
• Adapter. LoRA r16/α32 on all language-model projections (attention, MLP, and the DeltaNet projections in Qwen3.5); the vision tower is frozen.
• Calibration. Each size ships one temperature (2B 1.646, 4B 1.305, 9B 1.748; fitted by likelihood on 150 authored JevBench-style items, none from JevBench) applied to every question type × option-count bucket; the server applies it when started with --calibration. Temperature never changes an answer, only its probability.
• Abstention. unknown is a first-class option in training and inference. Insufficient evidence, a false premise, a mismatched reference or an answer outside the listed options all train toward unknown.

About a million training decisions in four stages, on open base models, for about $676 of rented GPU time for the whole project. The 2B and 4B went through all four stages (the 4B in one combined run of stages 1 and 2); the 9B, which produced the stage-2 labels, went from stage 1 to stage 3, then stage 4 with the others.

1. Licence-checked decisions (the 9B's first stage). Human-labelled image and text decisions from licence-verified sources, including roughly 300k image decisions converted from 21 public vision datasets.
2. New photo sources and pairs (the 2B and 4B). An earlier version of imajev-9b, trained on stage 1, labelled 546,964 decisions on six new photo and text sources, keeping 415,907; a label was kept only when two option orders agreed and the top probability was at least 0.6 (or unknown at least 0.5). 71,630 state-grounded (photo vs record) and two-image (reference vs target) decisions were added (54,468 labelled by the 9B, 17,162 by construction).
3. Hard typed questions (all sizes). 17,898 hard typed questions: synthetic documents and questions written by Qwen3.6-27B, answered independently by Qwen3.6-27B (thinking) and gpt-oss-20b, kept only on agreement (9,368 of 13,386), plus licence-verified human reasoning sets. 2 epochs, lr 3e-5. This is what restored reasoning: the stage-1 recipe had taken the 9B from 64.9% (untuned base) to 42.3% on JevBench hard; after these questions it scored 67.6%. The last part of the hard-question stage: 2,699 documents → 8,097 questions → 4,852 kept by unanimous agreement of three open-weight answerers (adding Qwen3.6-35B-A3B thinking), plus 4,214 replayed earlier hard questions (7,812 training rows). 2 epochs, lr 2e-5, continuing from the adapters trained on the earlier hard questions.
4. Soft targets, then a weight-space average (all sizes). 39,515 rows: the stage-3 teacher questions relabelled with full probability distributions from Qwen3.6-35B-A3B (thinking), 9,880 new hard, judge-style and programmatic questions, 10,570 rows of the Eikos decisions dataset (caiovicentino1/eikos-decisions, CC-BY-4.0, attribution and per-source licences in docs/eikos-decisions-usage.md; only its programmatic and human-annotated rows, nothing labelled by an API model) and 5,000 replayed image decisions. Soft cross-entropy on the teacher distribution, a rationale loss (weight 0.3, at most 192 tokens) and option permutation; 2 epochs, lr 2e-5, continuing from the stage-3 adapters (2B 620, 4B 747, 9B 1,018 steps). The checkpoint on its own gained on JevBench hard but lost photo-plus-record items on ImajevBench, so what ships is the element-wise average of the stage-3 adapter and this stage's best checkpoint (LoRA and readout): it keeps the image scores and most of the hard-question gain, and passes every release gate (ImajevBench within 1 point of stage 3, visual and joint item counts, probes, correct-unknown rate, false abstention, irrelevance).

Every teacher is open-weight. No JevBench items (8-gram contamination lint), no Jev outputs and no paid-API outputs were used in training. Total rented GPU across the project: about $676 on RunPod.

The pseudo-labelling pipeline (scripts/v2/pseudo_label.py) and the hard-question pipeline (scripts/p2/) work on your own data.

Data by stage.

• Stage 1 (2B, 9B; part of the 4B's first run): 504,000 decisions from 36 licence-admitted sources (15 text, 21 image), including 4,000 photo-vs-listing contradictions.
• Stage 2 (2B; part of the 4B's first run of 866,854 decisions; the 9B skipped it): 616,964 decisions labelled by the 9B, 475,305 kept; 71,630 photo-vs-record and two-photo decisions (17,162 of them labelled by construction).
• Stage 3 (all sizes), two rounds: 9,368 kept teacher questions plus 8,532 human reasoning items from 10 licensed sets, then 4,852 kept teacher questions trained with 4,214 replayed round-1 rows.
• Stage 4 (all sizes): 39,515 soft-target rows: the stage-3 teacher questions relabelled with teacher distributions, 9,880 new hard, judge-style and programmatic questions, 10,570 Eikos decisions rows, 5,000 replayed image decisions.

Training. LoRA r16/α32 on all language-model projections including DeltaNet (vision tower frozen), AdamW with weight decay 0, linear warm-up then cosine decay to 10% of the peak, gradient clipping 1.0, 4 GPUs (H100 or H200). Peak learning rates: stage 1 1e-4 for the 2B (after a 2e-4 initial run) and 2e-4 for the 9B; the 4B's first run 1.5e-4; stage 2 5e-5; stage 3 3e-5, then 2e-5; stage 4 2e-5 (soft cross-entropy plus a rationale loss of 0.3, option permutation), followed by the 50/50 weight-space average with the stage-3 adapter.

Compute. About $676 of rented GPU time on RunPod for the whole project, every run included: $499.07 through stage 3 and about $177 for stage 4 (6 h 20 min on one 8×H100 pod).

Full specification: docs/technical-specification.md

JevBench is text-only, so imajev ships a benchmark that is not. ImajevBench v2.0-lite has text-only, visual and joint (photo + state) items with an explicit Unknown reference; the test split is 279 items in 89 evidence clusters, 21 with an Unknown reference. It reports cluster-bootstrap CIs and pre-registered paired tests, and ranks direct option scoring and structured generation separately. It is a preview: all images are AI-generated and there has been no human audit yet. Data and datasheet in bench/, harness in src/imajev_bench, leaderboard in bench/LEADERBOARD.md. Run your model and send the row.

• Code and adapters: Apache-2.0. Base models: Qwen3.5-2B, -4B and -9B, Apache-2.0.
• Training data is admitted per source under a verified licence receipt (scripts/v1_text/common.py). New photo sources: PD12M (CC0), Wikimedia Commons (CC-BY-4.0, CC-BY-3.0 or CC0, checked per file), Open Images (CC-BY-2.0). 16 of the 21 image sources from stage 1 are admitted under their annotation licences only, with the photos remaining under their upstream terms (not redistributed); for abo, vizwiz, vizwiz_quality and defects the grant covers the images too. The receipts and the per-source table are in results/.
• No Jev outputs, no paid-API outputs and no benchmark test items were used in training. JevBench and typed-decisions test items were only ever evaluated on.
• The models output probabilities over options you supply. They are not a safety, medical, legal or hiring certificate.

• Single pass, no reasoning at inference. JevBench hard trails reasoning models; on the public hard split JevK5 and Eikos-4B are ahead of every size, and on the official board the 4B is #3 on Intelligence alone.
• Over-confident without calibration. Raw hard-item ECE is 0.16–0.19 (0.09–0.12 as shipped); serve with --calibration and --rotations 4.
• Photo-only requests need their own temperature. On photo-only verification (ABO + VizWiz, 823 items) the 4B's raw probabilities are already calibrated (ECE 0.015) and the shared temperature over-softens them (0.029). The schema-1.2 files calibration-modality.json / calibration-rot4-modality.json add a photo-only bucket (1.028) that the server applies when a request has images and an empty state (0.012); every other number is unchanged. The 2B and 9B still ship the single temperature. Fit report: results/calibration-modality/.
• The last part of the hard-question stage cost some reasoning-dev accuracy on our reasoning dev set (also used for checkpoint selection): 2B −5.6, 4B −1.2, 9B −1.8 points; the stage-4 checkpoints recovered most of it (62.7 / 67.2 / 68.9%), and the shipped averages were not measured on it.
• Our pre-registered test against the untuned base model is not significant for the 9B (+5.4 points over its untuned base, p = 0.131, on the shipped adapter; +6.1, p = 0.074 on the previous one), and the 4B and 9B are statistically indistinguishable on ImajevBench.
• The 2B abstains too rarely on ImajevBench's Unknown items (5/21, vs 18/21 and 15/21 for the 4B and 9B). The ImajevBench test split was also an input to choosing the shipped checkpoints (the release gates), so its numbers are not pure held-out estimates; on the hidden split (202 items, never published item by item) the shipped models score 74.3 / 85.6 / 84.7%.
• An empty field can read as "no". In the checked text app, a blank payment note was answered "not paid" (P = 0.06) instead of unknown. Unknown is trained for missing evidence, not guaranteed.
• Scribbles read as letters. The tracing pad reads 20 of 20 traced characters but calls 8 of 10 scribbles a letter.
• Two-image comparison is the weakest visual task (an earlier imajev-4b, before the hard-question stage: 41.8% on real pairs; not re-run on the released adapters).
• English only; at most two images, 32 KB state, 254 options, 8 questions per request. ImajevBench images are AI-generated.

• src/vision_decision/ request contracts, MLX backend, Jev API translation, calibration.
• scripts/playground/ the local server and the playground UI.
• scripts/train_decision_lora_torch.py, scripts/torch_decision.py training and the PyTorch path.
• scripts/v2/ data collection, templates and the 9B pseudo-labelling pipeline.
• scripts/p2/ hard typed-question generation, answering, assembly and temperature fitting.
• src/imajev_bench/, bench/ the benchmark.
• results/ every evaluation we report: results/imajev-1.0/ (the released models, their calibration files and release gates; previous-version/ holds the previous adapters and their earlier paired tests), results/benchmarks/ (JevBench and ImajevBench runs), plus reports on earlier checkpoints (results/earlier-checkpoints/).
• docs/ specs and the run book.

imajev is built and maintained by Mohit Garg (mohit67890 on GitHub and Hugging Face), with Claude (Anthropic) as a co-author on the code. To cite it, see CITATION.cff.

Work with me. I build decision systems like this for operations, support and back-office teams: refunds, returns, ticket routing, document and photo checks. See the case study or get in touch at mohitgarg.ai.

Qwen3.5 (Alibaba) for the base models; Qwen3.6 and gpt-oss (OpenAI) as open-weight teachers; TypeSafe's Jev documentation for the request contract this project mirrors; JevBench (fstandhartinger/jevbench) for the public text splits; kev (jaredpalmer/kev) as the sibling text-only project whose recipe notes were useful; PD12M (Spawning), Wikimedia Commons and Open Images for photos.