VisionPsy-Nano-460M-Flash

VisionPsy-Nano-460M-Flash is the efficiency-optimized sibling of VisionPsy-Nano-460M. It keeps the same ~460M parameter nanoVLM architecture but processes each image with far fewer visual tokens (as few as 64 at its native 512x512, versus 256-1088 for peers). The result is a model that responds an order of magnitude faster and with a smaller memory footprint on real phones, while giving up only a small amount of accuracy.

If VisionPsy-Nano-460M is our best-quality ~0.5B model, Flash is our best model for the edge: when time-to-first-token, battery, and RAM are the binding constraints, Flash is the one you ship.

• Fastest time-to-first-token (TTFT) in its class. By collapsing the image to as few as 64 visual tokens, Flash reaches the first token ~20-36x faster than nanoVLM-460M and SmolVLM2-500M, and consistently faster than LFM2.5-VL-450M and Qwen3.5-0.8B on Pixel 9, Galaxy S23, Galaxy S25, and iPhone 15.
• Small quality trade-off. Retains ~99% of the full model's quality (normalized score 61.4 vs 62.3), and it still beats the next best competitor (LFM2.5) on 13 of 17 benchmarks (plus 1 tie).
• Leaner on device. ~40% lower peak memory than nanoVLM-460M and SmolVLM2-500M, and higher decode throughput than nanoVLM-460M, SmolVLM2-500M, and Qwen3.5-0.8B in most device/backend configurations.
• Built for edge. ~460M params, native 512x512 processing, deployable as a 4-bit GGUF that fits comfortably on a phone.

---

Why Flash is fast: the visual-token lever

The dominant cost in a small VLM's prefill is the number of visual tokens the language model has to attend to. Flash keeps the same architecture as the full model but adopts a more efficient image-processing policy: it preserves each image's native resolution instead of upsampling it before tiling, so smaller images produce fewer tiles and far fewer visual tokens. The savings hold across resolutions — and against models like LFM2.5-VL-450M and Qwen3.5-0.8B, whose token counts balloon on large images, the gap actually widens at high resolution.

Visual tokens per image (fewer = faster prefill):

Input resolution	Flash	nanoVLM-460M	LFM2.5-VL-450M	SmolVLM2-500M	Qwen3.5-0.8B
512x512 (native)	64	1088	256	1088	256
512x1024	192	576	242	576	512
1024x662	320	832	228	832	672
2048x1024	576	576	2290	576	2048

At its native 512x512, Flash uses 17x fewer visual tokens than nanoVLM-460M and SmolVLM2-500M, and 4x fewer than LFM2.5-VL-450M and Qwen3.5-0.8B. At 2048x1024, LFM2.5-VL-450M and Qwen3.5-0.8B jump to 2,290 and 2,048 tokens while Flash stays at 576 — a ~4x advantage.

---

On-device efficiency

All numbers below are measured on real devices — Pixel 9, Samsung Galaxy S23, Samsung Galaxy S25, and iPhone 15 — using 4-bit (Q4_0) GGUF builds, reported as CPU / GPU. Lower is better for TTFT and memory; higher is better for decode throughput. Bold marks the best value in each cell group where Flash leads.

Time to first token (TTFT, seconds) — the headline

TTFT is what a user actually feels when they point the camera and ask a question. This is where Flash's token reduction pays off most.

At 512x512 (native resolution):

Model	Vis tokens	Pixel 9 (CPU/GPU)	Galaxy S23	Galaxy S25	iPhone 15
VisionPsy-Nano-460M-Flash	64	6.1 / 16.4	6.1 / 5.9	2.7 / 2.6	5.9 / 0.3
nanoVLM-460M (full)	1088	153.0 / 138.3	119.0 / 116.7	67.0 / 58.8	70.3 / 10.9
LFM2.5-VL-450M	256	14.9 / 21.9	13.6 / 14.2	7.7 / 5.7	3.4 / 0.4
SmolVLM2-500M	1088	128.2 / 136.1	135.5 / 113.7	48.7 / 64.3	72.1 / 10.7
Qwen3.5-0.8B	256	21.4 / 25.7	22.0 / 19.9	8.4 / 10.4	5.0 / 0.7

Takeaway: Picking the best backend per phone, Flash reaches the first token ~19-23x faster than nanoVLM-460M and SmolVLM2-500M on Pixel 9, Galaxy S23, and Galaxy S25, and up to ~36x on iPhone 15. It is also faster than LFM2.5-VL-450M on all four devices (~1.3-2.4x) and faster than Qwen3.5-0.8B across the board (~2.3-3.5x). (On iPhone 15 CPU alone, LFM is slightly ahead; using the iPhone GPU, Flash wins.)

At 2048x1024 (high-resolution / document pages):

Model	Vis tokens	Pixel 9 (CPU/GPU)	Galaxy S23	Galaxy S25	iPhone 15
VisionPsy-Nano-460M-Flash	576	51.5 / 156.0	51.5 / 58.8	21.7 / 24.7	33.9 / 2.8
nanoVLM-460M (full)	576	75.8 / 72.8	63.6 / 61.3	36.7 / 29.8	35.1 / 5.4
LFM2.5-VL-450M	2290	140.3 / 103.8	98.0 / 91.4	70.3 / 43.0	38.5 / 4.1
SmolVLM2-500M	576	62.1 / 72.5	70.9 / 59.9	29.2 / 33.8	36.7 / 5.4
Qwen3.5-0.8B	2048	311.4 / 325.2	265.2 / 248.9	127.5 / 137.3	64.8 / 14.8

Takeaway: At high resolution the token gap widens — LFM2.5-VL-450M and Qwen3.5-0.8B expand to 2,290 and 2,048 visual tokens while Flash holds at 576 — so Flash is the fastest to first token on 7 of 8 device/backends, roughly ~1.2-1.9x faster than nanoVLM-460M, ~1.5-2x faster than LFM2.5-VL-450M, and ~5-6x faster than Qwen3.5-0.8B. (The one exception is the Pixel 9 GPU, where Flash's high-resolution prefill regresses.)

Peak memory (RSS, MiB)

At 512x512 (native resolution):

Model	Pixel 9 (CPU/GPU)	Galaxy S23	Galaxy S25	iPhone 15
VisionPsy-Nano-460M-Flash	750 / 1692	746 / 1047	763 / 1066	292 / 285
nanoVLM-460M (full)	1236 / 2224	1232 / 1533	1251 / 1552	827 / 482
LFM2.5-VL-450M	501 / 1123	497 / 588	510 / 602	238 / 181
SmolVLM2-500M	1236 / 2224	1232 / 1534	1252 / 1552	780 / 482
Qwen3.5-0.8B	866 / 2243	853 / 942	878 / 972	903 / 836

At 2048x1024 (high-resolution / document pages):

Model	Pixel 9 (CPU/GPU)	Galaxy S23	Galaxy S25	iPhone 15
VisionPsy-Nano-460M-Flash	964 / 1915	960 / 1261	979 / 1279	567 / 399
nanoVLM-460M (full)	992 / 1949	988 / 1290	1005 / 1305	754 / 420
LFM2.5-VL-450M	535 / 1197	530 / 621	543 / 636	271 / 216
SmolVLM2-500M	993 / 1939	989 / 1290	1005 / 1306	719 / 420
Qwen3.5-0.8B	1080 / 2495	1066 / 1160	1081 / 1174	1153 / 941

At both resolutions Flash uses less peak memory than nanoVLM-460M and SmolVLM2-500M (~40% less than the full-token models at 512x512), and less than Qwen3.5-0.8B in six of eight device/backend configurations per resolution; Qwen keeps a small edge only on the Galaxy GPUs. LFM2.5-VL-450M remains the lightest of the group.

Decode throughput (tokens/s)

At 512x512 (native resolution):

Model	Pixel 9 (CPU/GPU)	Galaxy S23	Galaxy S25	iPhone 15
VisionPsy-Nano-460M-Flash	28.1 / 30.7	32.7 / 33.8	93.5 / 93.7	7.6 / 78.9
nanoVLM-460M (full)	15.6 / 27.9	23.2 / 17.8	47.0 / 51.9	8.3 / 52.6
LFM2.5-VL-450M	42.6 / 47.8	52.3 / 42.6	69.8 / 122.4	28.2 / 116.0
SmolVLM2-500M	18.2 / 28.1	18.5 / 18.3	64.8 / 49.6	11.4 / 53.6
Qwen3.5-0.8B	17.9 / 22.9	12.8 / 21.1	45.2 / 24.6	6.9 / 40.5

At 2048x1024 (high-resolution / document pages):

Model	Pixel 9 (CPU/GPU)	Galaxy S23	Galaxy S25	iPhone 15
VisionPsy-Nano-460M-Flash	23.3 / 13.3	27.7 / 23.3	89.7 / 66.2	9.8 / 71.7
nanoVLM-460M (full)	17.4 / 31.4	25.7 / 20.5	56.5 / 63.2	10.9 / 53.6
LFM2.5-VL-450M	26.3 / 48.9	38.5 / 35.0	39.7 / 76.3	28.9 / 123.4
SmolVLM2-500M	22.4 / 32.8	20.7 / 22.1	71.8 / 55.0	13.6 / 54.3
Qwen3.5-0.8B	12.6 / 20.6	15.3 / 17.0	36.8 / 32.5	7.0 / 24.4

Across the 16 device/backend configurations (two resolutions x four devices x CPU/GPU), Flash decodes faster than nanoVLM-460M and SmolVLM2-500M in 13 of 16, and faster than Qwen3.5-0.8B in 15 of 16. LFM2.5-VL-450M leads on sustained decode thanks to its hybrid backbone — but because Flash's TTFT is so much lower, Flash still wins end-to-end latency for the short answers typical of on-device VQA, where prefill dominates.

Where Flash wins, in one line

Holds at both 512x512 and 2048x1024:

• vs nanoVLM-460M and SmolVLM2-500M: wins on TTFT (~20-36x at 512x512, ~1.2-1.9x at 2048x1024) and memory across the board, and on decode throughput in 13 of 16 device/backend configurations.
• vs Qwen3.5-0.8B: wins on TTFT, on memory in 6 of 8 configurations per resolution (Qwen leads only on the Galaxy GPUs), and on decode throughput in 15 of 16 configurations.
• vs LFM2.5-VL-450M: wins decisively on TTFT (and the lead grows at high resolution, where LFM's token count balloons); LFM keeps an edge on peak memory and decode throughput.

Methodology: latency, memory, and throughput measured on-device with 4-bit (Q4_0) GGUF builds across Pixel 9, Galaxy S23, Galaxy S25, and iPhone 15 (CPU and GPU backends), mean over repeated runs.

---

An Efficient Operating Point

Flash keeps most of the full model's quality. All scores are computed in-house with a single VLMEvalKit harness so every model is scored identically, using each benchmark's official metric (POPE = F1, MMVet = partial credit, MM-IFEval = instruction-following accuracy, OCRBench = /1000, MME = Perception + Reasoning points). LLM-as-judge scoring uses Qwen3.6-27B.

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.

Benchmark	Metric	VisionPsy-Nano-460M-Flash	VisionPsy-Nano-460M
MMStar	acc	45.53	47.60
MMBench	acc	60.45	61.92
RealWorldQA	acc	58.43	60.00
MME	P+R	1619	1541
SEEDBench	acc	67.58	69.20
POPE	F1	87.46	87.93
MMMU	acc	30.67	31.44
MathVista	acc	47.80	48.90
AI2D	acc	66.39	66.48
ScienceQA	acc	84.04	86.47
OCRBench *	/1000	738 / 699	757 / 726
ChartQA *	acc	77.40 / 75.12	78.68 / 76.84
TextVQA *	acc	75.58 / 67.44	79.34 / 70.98
DocVQA *	acc	85.12 / 80.75	85.74 / 80.63
InfoVQA *	acc	51.12 / 44.80	49.80 / 43.29
MM-IFEval	IF-acc	43.67	42.30
MMVet	partial-credit	31.10	32.34

VisionPsy-Nano-460M-Flash demonstrates robust performance on general VQA and reasoning, with gains on MME and InfoVQA, while showing greater sensitivity on high-resolution OCR tasks.

• Flash keeps ~99% of the full model's normalized score (61.4 vs 62.3) while running an order of magnitude faster, and its normalized score still edges out LFM2.5-VL-450M (59.6).
• Flash still beats LFM2.5-VL-450M on 13 of 17 benchmarks (plus 1 tie), and stays ahead of SmolVLM2-500M on 16 of 17.
• The trade-off is concentrated in the OCR/document-heavy and fine-grained perception tasks (ChartQA, TextVQA, MMStar), where fewer visual tokens cost the most detail.

* 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); see the main VisionPsy-Nano-460M card for details.

For the full-quality model and its detailed comparisons against larger models (FastVLM-0.5B, Qwen3.5-0.8B, InternVL3.5-1B), see the VisionPsy-Nano-460M model card.

---

Model details

Property	Value
Developed by	Tether AI Research*
Parameters	~460M total
Built on	VisionPsy-Nano-460M / nanoVLM (base: lusxvr/nanoVLM-460M-8k)
Vision encoder	SigLIP2 base, patch16, 512x512
Language backbone	SmolLM2-360M (nanoVLM's LM)
Connector	pixel-shuffle MLP (64 image tokens / tile), same as the full model
Visual tokens	64 at native 512x512 (vs 256-1088 for peers)
Context length	8,192 tokens
Image handling	processed at native resolution (only upscaled below 512x512), then tiled
Precision	float32 (also shipped as GGUF for on-device)

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

---

Usage

VisionPsy-Nano-460M-Flash 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-Flash"
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())

For on-device deployment, use the 4-bit (Q4_0) GGUF build with a llama.cpp-based runtime.

---

Intended use

VisionPsy-Nano-460M-Flash is designed for latency- and memory-constrained, on-device multimodal applications where responsiveness matters more than squeezing out the last accuracy point: live camera Q&A, quick scene/document understanding, and lightweight visual instruction following on phones and other edge hardware. If you can afford more compute and want maximum quality, use VisionPsy-Nano-460M instead. 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.
• Efficiency numbers are measured with 4-bit GGUF builds on specific phones; absolute latency, memory, and throughput will vary with hardware, runtime, and quantization. Benchmark scores use a fixed in-house harness with an LLM judge (Qwen3.6-27B) and may differ from other reported setups.

Acknowledgements

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

Citation

@misc{visionpsynanoflash2026,
  title  = {VisionPsy-Nano-460M-Flash: An Efficiency-Optimized 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.