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):

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):

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):

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):

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

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):

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

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.

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

* 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.