VisionPsy-Nano: State-of-the-Art On-Device Vision-Language Models

KEY HIGHLIGHTS

• Compact VLMs built for the edge: Tether AI Research introduces VisionPsy-Nano, a family of compact (~460M-parameter) vision-language models (VLMs) purpose-built for on-device and edge deployment. It ships as two variants: VisionPsy-Nano-460M (tuned for quality) and VisionPsy-Nano-460M-Flash (tuned for latency), bringing multimodal understanding that used to require the cloud onto the phone in your pocket.
• Best-in-class at ~0.5B: VisionPsy-Nano-460M compares favorably to every other ~0.5B VLM tested, including LFM2.5-VL-450M, SmolVLM2-500M, and its own nanoVLM-460M-8k base, on 16 of 17 benchmarks, with a leading overall normalized score of 62.3 (vs 59.6 / 52.5 / 54.9).
• Leads every capability category: VisionPsy-Nano-460M tops all four categories: document understanding & OCR, visual perception, reasoning & knowledge, and instruction following & reliability. Its widest relative margins are in reasoning & knowledge (+7.4% over the next-best ~0.5B model) and visual perception (+4.6%).
• Punches above its weight: In the Instruction Following & Reliability category, covering both MM-IFEval (42.3) and POPE (87.9), VisionPsy-Nano-460M outperforms models 1.6x to 2.3x its size: FastVLM-0.5B (759M), Qwen3.5-0.8B (873M), and InternVL3.5-1B (1061M).
• Flash is an order of magnitude faster on real phones: By using far fewer visual tokens, VisionPsy-Nano-460M-Flash reaches the first token ~19–23x faster than nanoVLM-460M-8k and SmolVLM2-500M on Pixel 9, Galaxy S23, and Galaxy S25 Ultra, and up to ~36x on iPhone 15. It also stays ahead of the faster competitors, reaching the first token ~1.3–2.4x faster than LFM2.5-VL-450M and ~2.3–3.5x faster than Qwen3.5-0.8B across all four devices, while retaining ~99% of the full model's quality (61.4 vs 62.3 normalized).
• Ready to use: To accelerate development and innovation, Tether AI Research is today publicly releasing both models with three inference paths: full-precision reference quality via Transformers (from_pretrained); on-device via GGUF quantized checkpoints that run on a phone through llama.cpp (one-line invocation); and vLLM for high-throughput server inference.
• Open weights, reproducible evals: Released under Apache 2.0 with open weights, these models are intended to support researchers and for educational purposes. Every model is scored under the same VLMEvalKit protocol, with eval configs and judge setup included, so anyone can reproduce the benchmark numbers.

---

🚀 VisionPsy-Nano on Hugging Face & GitHub

All VisionPsy-Nano models, GGUF weights, and resources in one place.

---

HEADLINE RESULTS

The two figures below summarize where VisionPsy-Nano-460M stands. All numbers are computed in-house with a single VLMEvalKit [7] 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, OCRBench = /1000). All LLM-as-judge scoring uses Qwen3.6-27B [8].

Best-in-class at ~0.5B. VisionPsy-Nano-460M has the highest overall normalized score of any model in its ~0.5B weight class, and leads its cohort in every one of the four capability areas. Per-benchmark results across all 17 evaluations are in Benchmarks below.

Punching above its weight. On three full benchmarks (ScienceQA, MM-IFEval, and POPE), it beats every one of the larger 0.75-1B models outright:

---

Introducing VisionPsy-Nano

Tether Data, S.A. de C.V. (Tether AI Research, we, us, our) presents VisionPsy-Nano, a family of ~460M-parameter vision-language models that achieve state-of-the-art results for their size on a comprehensive suite of public benchmarks, while being purpose-built for edge deployment. The family has two variants:

• VisionPsy-Nano-460M: the best-quality ~0.5B model, for when accuracy is the priority.
• VisionPsy-Nano-460M-Flash: the best-latency model, for when time-to-first-token and RAM are the binding constraints. Same weight class, radically fewer visual tokens.

---

Why a 460M VLM

Vision-language models have advanced rapidly, but the best ones still live in the cloud. State-of-the-art open VLMs assume server-class GPUs with tens of gigabytes of memory, which conflicts with the privacy, latency, and offline-reliability needs of the places multimodal AI is most useful: a phone camera pointed at a document, a form, a chart, or a scene. The challenge is not only to make VLMs smaller; it is to make a small model that is genuinely accurate, responsive, and safe on the hardware people already carry.

On-device inference removes network round-trips, keeps images and documents on the user's device, and works offline, but it imposes a hard budget on parameters, memory, and latency. A phone typically exposes a small slice of RAM to a single app and has no dedicated VRAM, so a deployable VLM must be small and quantizable and fast to the first token. The dominant cost in a small VLM's prefill is the number of visual tokens the language backbone has to attend to, which is exactly the lever Flash pulls.

The current landscape forces a trade-off between quality and deployability. Models in the ~0.5B range (SmolVLM2-500M [2], the nanoVLM-460M base [3]) are deployable but leave significant accuracy on the table, particularly on reasoning, instruction following, and hallucination robustness. Slightly larger models (FastVLM-0.5B [4], Qwen3.5-0.8B [5], InternVL3.5-1B [6]) score higher on aggregate but cost more memory and are slower to first token, often dramatically so at high input resolution, where their visual-token counts balloon. VisionPsy-Nano was designed to close that gap.

---

Architecture

VisionPsy-Nano is built on nanoVLM [3] (base checkpoint lusxvr/nanoVLM-460M-8k), a clean, compact VLM architecture that pairs a SigLIP2 [9] vision encoder with a SmolLM2 [10] language backbone through a lightweight pixel-shuffle connector. Building on nanoVLM lets us concentrate the parameter budget on a single image-text path rather than a large, general-purpose multimodal stack. Both variants are released under Apache 2.0 as float32 checkpoints for reference-quality inference, with quantized GGUF builds for on-device use.

VisionPsy-Nano is trained and optimized for one image per query. This is a deliberate scoping choice for the target use cases (camera Q&A, document/chart/scene understanding), and it lets the model spend its limited capacity on getting single-image understanding right rather than spreading it across multi-image reasoning.

The full and Flash models share the same architecture and trained behavior; Flash differs only in its visual token budget, which is reduced by preserving the native image scale before tiling. Efficiency is a property of the architecture, not the weights.

Table 1. Model architecture and specification comparison.

---

How we trained it

Rather than simply scaling generic multimodal data, our central bet is that targeted supervision on the model's actual failure modes, plus checkpoint merging and alignment, matter more than raw data volume at this scale. This mirrors a broader trend in efficient post-training: curriculum-style SFT, model merging, and preference optimization each contribute a distinct, complementary improvement.

To find those failure modes, we built a failure-analysis framework with two complementary halves. A passive mining pass has the Stage 2 checkpoint answer every item in our training pool, scores the responses with rule-based checks and an LLM judge, and keeps only the hard, clean cases where the model answers incorrectly but the ground truth is entirely reliable. An active agentic harness hunts for weaknesses the training pool does not contain: a teacher VLM (Qwen3.6-27B [8]) repeatedly interrogates the student with realistic, user-style questions grounded in real images, grades each answer with the source image in view, and biases sampling toward the sources where the student is struggling. Over 300 rounds and ~18,000 probes it cataloged dozens of weaknesses, clustering into output-format failures, degenerate repetition, numeric reasoning, spatial reasoning, exhaustive extraction, and dense-numeral OCR. These clusters directly shaped the Stage 3 data mixture and motivated the replay training in Stage 5.

Starting from the nanoVLM-460M-8k [3] base, VisionPsy-Nano is produced by a five-stage post-training pipeline that combines supervised learning, checkpoint merging, and preference optimization:

Figure 1. Post-training workflow.

1. Stage 1: Generic SFT. Broad supervised fine-tuning on NVIDIA Nemotron-Image-Training-v3 [11], building wide multimodal coverage across documents, charts, diagrams, scenes, and scene-text. Samples whose images are perceptual-hash near-duplicates of held-out benchmarks are removed first.
2. Stage 2: Capability-Targeted SFT. Curated FineVision [12] and multimodal instruction-following data targeting OCR, documents, charts, formulas, spatial reasoning, and instruction following, complementing Nemotron's broad supervision while maintaining plain-answer, single-image training.
3. Stage 3: Weakness-targeted finetuning. A stronger teacher (Qwen3.6-27B [8]) distills verified, gold-anchored supervision from the mined failures. Because each mined item already carries a trusted answer, we keep that answer fixed and accept only teacher output that agrees with it. Mixed with real weakness-targeted data and replay, and trained with InfoSFT [13], this yields a set of capability specialists.
4. Stage 4: Model merging. The strongest specialists are merged with TIES-Merging [14], which trims each fine-tune, elects an agreed-upon sign per parameter, and averages only the aligned updates. Merging happens entirely in weight space, producing one ordinary checkpoint with the same architecture, parameter count, and inference cost as any individual run.
5. Stage 5: Preference alignment with replay. A final alignment stage with replay training to stop degenerate "doom-loop" repetition, fold in safety checks, and align responses more closely with human expectations.

This staging is important for compact edge models: broad SFT builds coverage, failure-driven SFT sharpens exactly the weak spots, merging stabilizes the result, and alignment fixes the behaviors (looping, unsafe or off-format answers) that pure imitation learning tends to leave behind.

---

Reliability and safety

A doom loop is not simply a verbose answer. It occurs when the model enters a self-reinforcing repetition pattern, repeating a phrase, sentence, or formatting token until the generation limit is reached, often without producing an end-of-sequence token. These failures are easy to miss in multiple-choice and short-answer benchmarks, where generation ends before the loop can develop. Rather than relying on generic anti-repetition data, we mine preference pairs directly from the Stage 4 model: when the same prompt yields both a cleanly terminated response and a genuine loop, the former becomes the chosen response and the latter the rejected one. This same-prompt construction isolates the unwanted behavior without changing the task, answer style, or visual input. We train on these pairs with MPO [15], plus capability replay to protect instruction following, OCR, and visual reasoning.

Table 2. Doom-loop rate on a 395-case stress test covering recipes and visual how-to questions, long STEM and chart reasoning, exhaustive lists, and structured outputs.

Safety training combines carefully filtered examples from the public portion of PKU-SafeRLHF-V [16] with internally curated cases covering harmful requests, privacy, self-harm, fraud, visual prompt injection, and other deployment risks. The mixture also contains benign boundary cases that should be answered normally, because the objective is not blanket refusal but the correct decision to answer, safely assist, abstain, or refuse.

We then stress-test every checkpoint with a VLM-native red-teaming harness. Each model faces 288 adversarial cases spanning 8 vulnerability categories and 9 attack methods across two channels: image-borne attacks that render the harmful instruction directly into the image (FigStep [17], typographic overlay, prompt-in-image) and text-channel jailbreaks over a blank canvas (roleplay, prompt injection, Base64, ROT13, leetspeak, plain text). All attacks come from a fixed, curated bank, so the scan is fully reproducible.

Across the 288 cases, VisionPsy-Nano-460M passes 76.9%, against 65.9% for the nanoVLM-460M-8k base it started from and 61.9% for SmolVLM2-500M, so alignment adds 11 points of adversarial robustness over the base. LFM2.5-VL-450M is comparable at 79.0%, with most of that difference concentrated in PersonalSafety; on six of the eight categories the two models sit within one or two cases of each other at 36 cases per category.

Figure 2. Safety red-teaming pass rates by vulnerability category.

---

Benchmarks

All numbers are computed in-house with a single VLMEvalKit [7] 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, OCRBench = Final Score (/1000). Each model is evaluated on its own full sample set, and all LLM-as-judge scoring uses Qwen3.6-27B [8]. Open-ended VQA benchmarks (ChartQA, TextVQA, DocVQA, InfoVQA, OCRBench) are notoriously sensitive to string-matching artifacts ("12%" vs "12 percent", paraphrases, units, formatting), so on those we report LLM-judge / strict pairs.

The changes we 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.

We group the 17 public benchmarks into four capability areas. VisionPsy-Nano-460M leads its ~0.5B cohort in every one of them. Scores are normalized to 0-100 (MME /2800, OCRBench /1000; percentages otherwise).

Table 3. VisionPsy-Nano-460M is the best ~0.5B model in all four capability areas.

Per benchmark, VisionPsy-Nano-460M wins 15 of the 17 rows outright against the full ~0.5B cohort. On MMMU it sits 0.2 points behind SmolVLM2-500M, within noise at this sample size, so it compares favorably on 16 of 17; MMVet, where LFM2.5-VL-450M leads by 3.7 points, is the one clear loss. Against LFM2.5-VL-450M alone, its closest competitor, it leads on 16 of 17. To confirm the lead is not an artifact of the judge, we re-scored both models with GPT-4o-mini and GPT-5-chat in place of Qwen3.6-27B. The trend and the margin in normalized score remain almost identical (62.3 / 61.6 / 62.9 for VisionPsy-Nano-460M against 59.6 / 58.7 / 60.1 for LFM2.5-VL-450M), with the same 16 of 17 win count under every judge.

Figure 3. Per-benchmark performance by capability area against the ~0.5B cohort.

At roughly half to two-thirds the parameters, VisionPsy-Nano-460M still beats FastVLM-0.5B [4] (~0.75B), Qwen3.5-0.8B [5], and InternVL3.5-1B [6] outright on 3 full benchmarks, and on many specific capabilities even where the larger models win on aggregate.

Table 4. The first three rows are full benchmarks; the last three are subcategories within larger benchmarks. N gives the sample count in each case. The larger models win the raw 17-benchmark average (Qwen3.5-0.8B 66.1, InternVL3.5-1B 65.9 vs VisionPsy-Nano-460M 62.3), which is expected given the parameter gap. The narrower claim here is that a 460M model still leads all three on three complete benchmarks and on the specific skills below them.

---

Flash: efficiency on real devices

VisionPsy-Nano-460M's image pipeline resizes the longest image side to 2048 pixels before tiling. This policy is effective for high-resolution inputs, but is inefficient for smaller images: upsampling increases the number of tiles and visual tokens without adding new image content. We therefore derive VisionPsy-Nano-460M-Flash from VisionPsy-Nano-460M by retaining the same model architecture and training procedure, while changing the image preprocessing policy. Instead of normalizing all inputs to the backbone resolution, Flash processes images at their original size. Only images smaller than 512x512 are upscaled to this minimum resolution.

Flash trades a little accuracy for a large latency win by feeding the backbone a fraction of the visual tokens at the same input resolution, avoiding tokens spent on spatial detail introduced solely by interpolation. It does not use token pruning, token merging, or a learned compression module; the reduction follows directly from preserving the native image scale before tiling.

Figure 4. Visual preprocessing in VisionPsy-Nano-460M (Nano) and VisionPsy-Nano-460M-Flash (Flash). Nano upsamples inputs to a longest side of 2048 before tiling, whereas Flash preserves the native resolution, with a minimum size of 512×512. This avoids unnecessary resolution inflation and yields a smaller number of visual tokens.

Visual token footprint

Flash often produces the shortest visual sequence, with the largest gains observed for low-resolution inputs. For a native 512x512 image, Flash uses 64 tokens, compared with 256 for LFM2.5-VL [1] and Qwen3.5 [5], and 1088 for nanoVLM [3] and SmolVLM2 [2], corresponding to a 4×–17× reduction. The advantage remains across larger and non-square inputs.

Table 5. Visual-token count at different input resolutions. Lower is better.

On-device Time to Tirst Token

Flash achieves the lowest latency across all tested devices. On the common runtime, it reduces TTFT by 11.9–25.1x relative to nanoVLM-460M and SmolVLM2-500M. Selecting the fastest available backend on each device, Flash is also 1.3–2.4x faster than LFM2.5-VL-450M and 2.3–3.5x faster than Qwen3.5-0.8B. This reduction follows the substantially shorter visual sequence. All device numbers are measured on real phones (Pixel 9, Galaxy S23, Galaxy S25 Ultra, iPhone 15) using 4-bit (Q4_0) GGUF builds. TTFT is what a user feels when they point the camera and ask a question, and it is where Flash's token reduction pays off most.

Figure 5. On-device time to first token across models. TTFT is measured on four mobile devices using a 512 × 512 input. Each entry reports CPU/GPU latency in seconds. Lower is better.

Memory follows the same pattern: at 512x512, Flash reduces peak resident memory by 24-39% on Android and 41-65% on iPhone 15 against the full-token baselines, and beats them on decode throughput in 13 of 16 device and backend configurations. LFM2.5-VL-450M achieves the lowest absolute memory and highest throughput in most settings, showing both are strongly affected by architecture and runtime as well as token count.

On-device Time to Last Token

Practical responsiveness also depends on the time to produce a complete response. Because standard VLMEvalKit queries demand few-token outputs, we profile with the prompt "Please describe the image in one sentence", which proxies a realistic interaction while constraining response length.

Flash achieves the lowest time-to-last-token across all tested Android devices, requiring 10.6s on the Pixel 9, 7.4s on the Galaxy S23, and 4.2s on the Galaxy S25 Ultra. Compared to LFM2.5-VL-450M, the most comparable baseline in terms of instruction following and response length, this yields speedups of 2.5x, 2.1x, and 1.8x respectively (on the iPhone 15, both models finish in 0.7s). Crucially, Flash generates slightly more tokens on average than LFM2.5-VL-450M (35.9 vs 29.1), so the latency advantage is not an artifact of shorter responses. nanoVLM and SmolVLM2 average 136.4 and 254.4 tokens despite the explicit one-sentence constraint, so their higher TTLT reflects the computational penalty of poor instruction adherence.

Figure 6. Time to Last Token (TTLT, in seconds) on different mobile devices. Lower is better. Visual and output token counts are also reported for comparison.

What Flash costs

Flash preserves the core capabilities of the full model at a significantly reduced cost, scoring 61.4 normalized against 62.3, or about 99% of the quality. Gaps are under one point on AI2D, POPE, and MMMU, and the efficient variant even improves on MME (+78 points), MM-IFEval (+1.4), and InfoVQA (+1.3). More noticeable degradations emerge on OCR-heavy and fine-grained reasoning benchmarks, particularly TextVQA, OCRBench, and ScienceQA, suggesting that tasks reliant on high-resolution text recognition are inherently more sensitive to this optimization. If your workload is dense document OCR, use the full model; otherwise Flash is a highly favorable operating point.

---

Usage

VisionPsy-Nano runs across three interchangeable runtimes, so you can move from a research prototype to a phone without changing checkpoints. The 🤗 Transformers reference path is shown below; for high-throughput vLLM [19] serving and on-device llama.cpp [18] (GGUF) deployment, the inference repository ships ready-to-run setup, build, and inference scripts. Quantized GGUF builds are available for on-device use (VisionPsy-Nano-460M-GGUFs and VisionPsy-Nano-460M-Flash-GGUFs); the 5-bit (Q5_K_M) build of Flash is a good quality/size operating point, and a 4-bit (Q4_0) build is used for the on-device latency numbers above.

Both models load directly with 🤗 Transformers via trust_remote_code, no extra repo to clone. Requires Python ≥ 3.10, transformers>=4.46, and PyTorch ≥ 2.4 (CUDA GPU recommended; CPU works, slower).

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 & limitations

VisionPsy-Nano 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.

• Single-image by design: recommend one image per query; multi-image prompts are outside its intended use.
• As a compact model it may occasionally hallucinate or miscount, and is best on focused tasks rather than very dense documents or long multi-step math.
• Primarily English; other languages are not officially supported yet.
• Not intended for safety-critical or high-stakes automated decisions.

---

Conclusion

VisionPsy-Nano shows that a compact, single-image vision-language model can be best-in-class at ~0.5B, beat models up to ~2x larger on the skills that matter, and still run fast enough and small enough to ship on a phone. The two variants let builders choose their point on the quality/latency curve: VisionPsy-Nano-460M for maximum accuracy, VisionPsy-Nano-460M-Flash for maximum responsiveness. The central lesson is the same as its methodology: failure-driven data, checkpoint merging, and alignment, not raw scale, are what close the gap to much larger models at the edge.

What's next

A full technical report covering the complete 17-benchmark results, the failure-analysis framework, per-stage data curation, the TIES merge configuration, and the full safety evaluation will follow this post. We are also working on an in-browser WebGPU demo so you can try both variants without installing anything, and we welcome fine-tunes, quantizations, and bug reports on the GitHub repository.

Acknowledgements

Built on the excellent open-source work of nanoVLM [3], SmolLM2 [10], and SigLIP2 [9], and evaluated with VLMEvalKit [7].

Citation

@misc{visionpsynano2026,
title = {VisionPsy-Nano: State-of-the-Art On-Device Vision-Language Models},
author = {Tether AI Research},
year = {2026},
note = {Hugging Face blog}
}

References

[1] Liquid AI. "LFM2.5-VL-450M." Hugging Face model card, 2026. https://huggingface.co/LiquidAI/LFM2.5-VL-450M

[2] Hugging Face. "SmolVLM2-500M-Video-Instruct." Hugging Face model card, 2025. https://huggingface.co/HuggingFaceTB/SmolVLM2-500M-Video-Instruct. Related paper: Marafioti, A. et al. "SmolVLM: Redefining Small and Efficient Multimodal Models." arXiv preprint arXiv:2504.05299, 2025. https://arxiv.org/abs/2504.05299

[3] Hugging Face. "nanoVLM-460M-8k." Hugging Face model card, 2025. https://huggingface.co/lusxvr/nanoVLM-460M-8k. Project code: https://github.com/huggingface/nanoVLM

[4] Vasu, P. K. A. et al. "FastVLM: Efficient Vision Encoding for Vision Language Models." CVPR, 2025. https://arxiv.org/abs/2412.13303. Model card: https://huggingface.co/apple/FastVLM-0.5B

[5] Qwen Team. "Qwen3.5-0.8B." Hugging Face model card, 2026. https://huggingface.co/Qwen/Qwen3.5-0.8B

[6] Wang, W. et al. "InternVL3.5: Advancing Open-Source Multimodal Models in Versatility, Reasoning, and Efficiency." arXiv preprint arXiv:2508.18265, 2025. https://arxiv.org/abs/2508.18265. Model card: https://huggingface.co/OpenGVLab/InternVL3_5-1B

[7] Duan, H. et al. "VLMEvalKit: An Open-Source Toolkit for Evaluating Large Multi-Modality Models." ACM Multimedia, pp. 11198–11201, 2024. https://arxiv.org/abs/2407.11691. Software: https://github.com/open-compass/VLMEvalKit

[8] Qwen Team. "Qwen3.6-27B." Hugging Face model card, 2026. https://huggingface.co/Qwen/Qwen3.6-27B

[9] Tschannen, M. et al. "SigLIP 2: Multilingual Vision-Language Encoders with Improved Semantic Understanding, Localization, and Dense Features." arXiv preprint arXiv:2502.14786, 2025. https://arxiv.org/abs/2502.14786. Model card: https://huggingface.co/google/siglip2-base-patch16-512

[10] Ben Allal, L. et al. "SmolLM2: When Smol Goes Big — Data-Centric Training of a Small Language Model." arXiv preprint arXiv:2502.02737, 2025. https://arxiv.org/abs/2502.02737. Model card: https://huggingface.co/HuggingFaceTB/SmolLM2-360M-Instruct

[11] NVIDIA. "Nemotron-Image-Training-v3." Hugging Face dataset card, 2026. https://huggingface.co/datasets/nvidia/Nemotron-Image-Training-v3

[12] Wiedmann, L. et al. "FineVision: Open Data Is All You Need." arXiv preprint arXiv:2510.17269, 2025. https://arxiv.org/abs/2510.17269. Dataset card: https://huggingface.co/datasets/HuggingFaceM4/FineVision

[13] Sabbaghi, M., Pappas, G., Javanmard, A., and Hassani, H. "InfoSFT: Learn More and Forget Less with Information-Aware Token Weighting." arXiv preprint arXiv:2605.14967, 2026. https://arxiv.org/abs/2605.14967

[14] Yadav, P., Tam, D., Choshen, L., Raffel, C., and Bansal, M. "TIES-Merging: Resolving Interference When Merging Models." NeurIPS 36, 2023. https://arxiv.org/abs/2306.01708. Code: https://github.com/prateeky2806/ties-merging

[15] Wang, W. et al. "Enhancing the Reasoning Ability of Multimodal Large Language Models via Mixed Preference Optimization." arXiv preprint arXiv:2411.10442, 2024. https://arxiv.org/abs/2411.10442

[16] Ji, J. et al. "Safe RLHF-V: Safe Reinforcement Learning from Multi-modal Human Feedback." arXiv preprint arXiv:2503.17682, 2025. https://arxiv.org/abs/2503.17682. Dataset card: https://huggingface.co/datasets/PKU-Alignment/PKU-SafeRLHF-V

[17] Gong, Y. et al. "FigStep: Jailbreaking Large Vision-Language Models via Typographic Visual Prompts." AAAI 39(22), pp. 23951–23959, 2025. https://doi.org/10.1609/aaai.v39i22.34568. Code: https://github.com/ThuCCSLab/FigStep

[18] Gerganov, G. et al. "llama.cpp: LLM Inference in C/C++." Software repository, 2023–2026. https://github.com/ggml-org/llama.cpp

[19] Kwon, W. et al. "Efficient Memory Management for Large Language Model Serving with PagedAttention." SOSP, 2023. https://arxiv.org/abs/2309.06180. Software: https://github.com/vllm-project/vllm