VisionPsy-Nano-460M

VisionPsy-Nano-460M is a compact (~460M parameter) vision-language model built for on-device and edge deployment. It is built on top of nanoVLM. Despite its size, it compares favorably on 16 of 17 public benchmarks and matches or beats models up to ~2x larger on knowledge reasoning, visual instruction following, and hallucination robustness.

• Best-in-class among ~0.5B VLMs: compares favorably to LFM2.5-VL-450M, SmolVLM2-500M, and nanoVLM-460M-8k on 16 of 17 benchmarks.
• Punches above its weight: beats the larger FastVLM-0.5B (~0.75B), Qwen3.5-0.8B, and InternVL3.5-1B outright on ScienceQA, MM-IFEval, and POPE, and on many fine-grained reasoning/perception capabilities.
• Efficient architecture: built on nanoVLM (SigLIP2 vision encoder + SmolLM2 language backbone), ~460M params total, 8K token context, native 512x512 image processing.

Where VisionPsy-Nano-460M leads

To showcase where the model is strongest, we group the 17 public benchmarks into four core capability areas — Document Understanding & OCR, Visual Perception, Reasoning & Knowledge, and Instruction Following & Reliability. VisionPsy-Nano-460M leads its ~0.5B cohort in every one of these areas. Scores are normalized to 0-100 for cross-benchmark comparison (MME /2800, OCRBench /1000; percentages otherwise).

Per-benchmark detail within each capability area:

Model details

* References to Tether AI Research are references to Tether Data, S.A. de C.V.

Benchmarks

All numbers below are computed in-house with a single VLMEvalKit harness so every model is scored identically, using each benchmark's official metric: accuracy for most, POPE = F1, MMVet = partial credit, MM-IFEval = instruction-following accuracy, MME = Perception + Reasoning score, OCRBench = Final Score (out of 1000). Each model is evaluated on its own full sample set. All LLM-as-judge scoring uses Qwen3.6-27B as the judge.

The changes used for these numbers are currently under review in VLMEvalKit:

• VisionPsy model support: PR #1613
• Opt-in LLM-judge rescoring for open-ended VQA benchmarks: PR #1602
• MM-IFEval bug fix: PR #1601
• LLM-judge bug fix: PR #1611

Until they are merged, you can reproduce the benchmarks by applying these PRs on top of VLMEvalKit.

Similar-size models (~0.45-0.5B)

Bold = best score in the row across the similar-size cohort. Sorted by VisionPsy-Nano's lead. Scores are % unless noted (MME = P+R points, OCRBench = /1000). Starred (*) rows show LLM-judge / strict.

VisionPsy-Nano-460M compares favorably on 16 of 17 benchmarks, with MMVet the only clear exception.

* ChartQA, TextVQA, DocVQA, InfoVQA, and OCRBench are shown as LLM-judge / strict. On these open-ended benchmarks, strict string/heuristic matching lowers every model's score, but an LLM-as-judge (Qwen3.6-27B) is a more reliable evaluation of free-form answers (e.g., "12%" vs "12 percent", paraphrases, units, formatting). Full analysis in the blog post.

Beating larger models (0.75-1B)

At roughly half to two-thirds the parameters, VisionPsy-Nano-460M still beats FastVLM-0.5B (~0.75B), Qwen3.5-0.8B, and InternVL3.5-1B outright on 3 full benchmarks, and outperforms all three on many specific reasoning/perception capabilities even where the larger models win on aggregate. Bold = VisionPsy-Nano leads all three larger models.

The 3 "full benchmark" rows are outright wins over all three larger models. The "subcategory" rows are fine-grained capabilities (N >= 40) from suites where the larger models may lead on aggregate — the point being that a 460M model can still beat models up to ~2x its size on these specific skills. All scores are accuracy except POPE (F1).

Usage

VisionPsy-Nano-460M loads directly with 🤗 Transformers via trust_remote_code — no extra repo to clone. Requires Python ≥ 3.10, transformers>=4.46 (tested with 5.13.1), and PyTorch ≥ 2.4 (CUDA recommended).

import torch
from PIL import Image
from transformers import AutoModelForImageTextToText, AutoProcessor

repo = "qvac/VisionPsy-Nano-460M"
device = "cuda" if torch.cuda.is_available() else "cpu"

model = AutoModelForImageTextToText.from_pretrained(
    repo,
    trust_remote_code=True,
    dtype="auto" if device == "cuda" else torch.float32,
).to(device).eval()
processor = AutoProcessor.from_pretrained(repo, trust_remote_code=True)

# apply_deploy_profile() enables torch.compile + CUDA graphs (fastest on GPU);
# use apply_eager_profile() for plain eager execution or CPU.
if device == "cuda":
    model.apply_deploy_profile(model.device)
else:
    model.apply_eager_profile()

# The processor applies the chat template and inserts image tokens for you —
# just pass the raw image(s) and a plain-text prompt.
image = Image.open("your_image.jpg").convert("RGB")
inputs = processor(images=image, text="What is in this image?", return_tensors="pt")
inputs = {
    k: (v.to(device) if torch.is_tensor(v) else v)
    for k, v in inputs.items()
    if v is not None
}
inputs.pop("pixel_values", None)

with torch.inference_mode():
    out = model.generate(**inputs, max_new_tokens=128, greedy=True)
print(processor.batch_decode(out, skip_special_tokens=True)[0].strip())

Intended use

VisionPsy-Nano-460M targets latency- and memory-constrained, on-device multimodal applications: visual question answering, document/chart/diagram understanding, scene-text reading, and lightweight visual instruction following. Because of its small size, we recommend fine-tuning on your specific domain to maximize quality.

Limitations

• Single-image by design: the model is trained and optimized for one image per query, so we recommend single-image inputs at inference; multi-image prompts are outside its intended use.
• As a compact model, it may occasionally hallucinate or miscount and is best suited to focused tasks rather than very dense documents or long multi-step math, where larger models have an edge.
• Primarily English; other languages are not officially supported yet.
• Not intended for safety-critical or high-stakes automated decisions.
• Benchmark scores are produced with a fixed in-house harness and an LLM judge (Qwen3.6-27B); absolute numbers may differ from other reported setups.

Acknowledgements

Built on the excellent open-source work of nanoVLM, SmolLM2, and SigLIP2.

Citation

@misc{visionpsynano2026,
  title  = {VisionPsy-Nano-460M: A Compact Vision-Language Model for On-Device Inference},
  author = {Tether AI Research},
  year   = {2026},
  note   = {Hugging Face model card}
}

Copyright

We will take appropriate actions in response to notices of copyright infringement. If you believe your work has been used or copied in a manner that infringes upon your intellectual property rights, please email data-apps@tether.io identifying and describing both the copyrighted work and alleged infringing content.

Licensing

This model, which was finetuned as described in the blog post, is licensed by Tether Data, S.A. de C.V. under the Apache 2.0 license. As described in the blog post, this model is a version of the NanoVLM-460M-8k pre-trained model (https://huggingface.co/lusxvr/nanoVLM-460M-8k), which is made available under the MIT license.

The FineVision dataset (https://huggingface.co/datasets/HuggingFaceM4/FineVision) is made available under the CC-BY-4.0 (Creative Commons - Attribution 4.0) license. FineVision is an aggregation of a number of public sources unified into a single corpus. Individual subsets within the collection may inherit specific underlying terms from their original creators. As described in the blog post, a subset of the FineVision dataset was used as a part of finetuning the model.

The NVIDIA Nemotron-Image-Training-v3 dataset (https://huggingface.co/datasets/nvidia/Nemotron-Image-Training-v3) is made available under the CC-BY-4.0 (Creative Commons - Attribution 4.0). The mPLUG TinyChartData dataset (https://huggingface.co/datasets/mPLUG/TinyChartData) is made available under the Apache 2.0 license. The TabMWP dataset (https://promptpg.github.io/) is made available under the CC BY-NC-SA 4.0 (Creative-Commons-Attribution-NonCommercial-ShareAlike 4.0). The PopVQA dataset (https://huggingface.co/datasets/idoco/PopVQA) is made available under the MIT license. The InfoSeek dataset (https://github.com/open-vision-language/infoseek) is made available under the Apache 2.0 license. The MMKU-Bench dataset (https://huggingface.co/datasets/baochenfu/MMKU-Bench) is made available under the Apache 2.0 license. The VisionFoundry-10K dataset (https://huggingface.co/datasets/zlab-princeton/VisionFoundry-10K) is made available under the Apache 2.0 license. The PKU-SafeRLHF-V dataset (https://huggingface.co/datasets/PKU-Alignment/PKU-SafeRLHF-V) is made available under the CC-BY-NC 4.0 (Attribution-NonCommercial 4.0 International). As described in the blog post, the NVIDIA Nemotron-Image-Training-v3, mPLUG TinyChartData, TabMWP, PopVQA, InfoSeek, MMKU-Bench, VisionFoundry-10K and PKU-SafeRLHF-V datasets were used as a part of finetuning the model.