Tether AI Research* is releasing VisionPsy-Nano, a family of ~460M-parameter vision-language models built to run on the device in your pocket.
There are two variants: VisionPsy-Nano-460M when accuracy is the priority, and VisionPsy-Nano-460M-Flash when time-to-first-token, and memory are what matters most.
Download VisionPsy-Nano now on HuggingFace: https://huggingface.co/collections/qvac/visionpsy
Best in its weight class
Against every other ~0.5B vision model tested (LFM2.5-VL-450M, SmolVLM2-500M, and its own nanoVLM-460M-8k base), VisionPsy-Nano-460M leads on 16 of 17 benchmarks, with the highest overall normalized score in its class:
| Model | Overall normalized score |
|---|---|
| VisionPsy-Nano-460M | 62.3 |
| LFM2.5-VL-450M | 59.6 |
| nanoVLM-460M-8k | 54.9 |
| SmolVLM2-500M | 52.5 |
It also leads all four capability categories, not just the average: document understanding and OCR (73.9), visual perception (61.5), reasoning and knowledge (52.2), and instruction following and reliability (65.1). Its widest margins are the two that usually break small models: reasoning and knowledge (+7.4% over the next best ~0.5B model) and visual perception (+4.6%).
It punches above its size class
The more interesting result is what happens when you stop comparing it to its own weight class. On three full benchmarks, a 460M model beats every one of the 0.75B to 1B models tested outright, including Apple's FastVLM-0.5B (759M), Qwen3.5-0.8B (873M), and InternVL3.5-1B (1061M), which are 1.6x to 2.3x its size:
| Benchmark | VisionPsy-Nano-460M | FastVLM-0.5B | Qwen3.5-0.8B | InternVL3.5-1B |
|---|---|---|---|---|
| ScienceQA | 86.5 | 84.7 | 71.6 | 79.7 |
| MM-IFEval (instruction following) | 42.3 | 21.1 | 36.9 | 33.6 |
| POPE (hallucination robustness) | 87.9 | 86.5 | 87.3 | 86.0 |
MM-IFEval matters more than it looks: it measures whether the model actually does what you asked. Leading every larger model tested on that axis is the difference between a model you can build a product on and one you have to babysit.
Flash: the first token, on a real phone
The cost that decides whether on-device vision feels usable is not the model size, it is how long you wait after pointing the camera. That wait is driven by the number of visual tokens the model has to read. Flash uses 64 visual tokens where the full model uses 1088, and it keeps the quality: within about 1% of the full model (61.4 vs 62.3 normalized).
The result, measured on real phones with quantized GGUF builds at 512x512:
| Device | Flash, time to first token |
|---|---|
| iPhone 15 | 0.3s |
| Galaxy S25 Ultra | 2.6s |
| Galaxy S23 | 5.9s |
| Pixel 9 | 6.1s |
That is 11.9x to 25.1x faster to the first token than nanoVLM-460M and SmolVLM2-500M on the same runtime, and still 1.3x to 2.4x faster than LFM2.5-VL-450M and 2.3x to 3.5x faster than Qwen3.5-0.8B across all four devices. Peak memory drops 24% to 39% on Android and 41% to 65% on iPhone 15 against the full-token baselines.
Built to run locally, not shrunk to fit
VisionPsy-Nano is not a cloud model trimmed down until it could run on a phone. Running on the device was the design constraint from the start, and it shaped every choice: the parameter budget, the visual-token budget that Flash pulls on, the decision to optimize for a single image per query, and the quantized builds that ship next to the full-precision weights. A phone hands one app a small slice of RAM and no dedicated VRAM, so a model that is going to live there has to be small, quantizable, and fast to the first token. That is what it was built to be.
What that buys is what local AI is for. The image is understood where it was taken, so it never has to leave the device to be read. The model keeps working with no signal. And it fits the situations it was scoped for: asking questions about what the camera is pointed at, reading documents, charts and diagrams, pulling text out of a scene, and following light visual instructions.
How it got there: Failure-driven, not scale-driven
The result did not come from scaling data. It came from finding out precisely where the model was wrong and fixing that.
Tether AI Research built an agentic failure-discovery harness: a larger teacher model interrogates the small model with realistic questions on real images, grades every answer with the image in view, then clusters what it found into a weakness catalogue that steers the next round. Over 300 rounds and roughly 18,000 probes, it mapped concrete failure modes: misread prices and license plates, reading a chart value correctly but failing to sum a column, confusing left and right, and degenerate repetition loops.
Those clusters became the training signal. A five-stage post-training pipeline then turns a good base model into a best-in-class one: broad supervised fine-tuning, capability-targeted fine-tuning, weakness-targeted fine-tuning on teacher-verified synthetic data, merging the resulting capability specialists into a single checkpoint with TIES so their strengths accumulate at no extra inference cost, and a final preference-alignment stage that kills the repetition loops.
Get it
Open weights under Apache 2.0, these models are intended to support researchers and for educational purposes, with three ways to run them today: full precision via Transformers, quantized GGUF builds for on-device inference through llama.cpp, and vLLM for high-throughput server inference. Support in the QVAC SDK is coming.
Every model in the report was scored under one VLMEvalKit harness with the eval configs and judge setup published, so the benchmark numbers are reproducible.
* References to Tether AI Research are references to Tether Data, S.A. de C.V.
References:
Hugging Face VisionPsy-Nano Collection: https://huggingface.co/collections/qvac/visionpsy
Hugging Face Blog Article: https://huggingface.co/blog/qvac/visionpsy
Top comments (0)