Top 10 vision-language-modellen in 2026

Vision Language Models (VLM's) veranderen industrieën razendsnel doordat ze AI-systemen in staat stellen zowel beelden als tekst te begrijpen en erover te redeneren. In tegenstelling tot traditionele computer vision-modellen kunnen moderne VLM's complexe beelden interpreteren, gedetailleerde vragen over visuele content beantwoorden en zelfs video's en documenten met ingesloten tekst verwerken. 

Dankzij deze eigenschap zijn ze van onschatbare waarde voor medische diagnostiek, geautomatiseerde kwaliteitscontrole en gevoelige toepassingen waar precisie belangrijker is dan snelheid.

In deze blog bespreken we de beste vision-language-modellen van 2026, zowel open-source als propriëtair. We lichten hun unieke mogelijkheden uit en presenteren vervolgens hun prestaties en benchmarkresultaten. Voor ontwikkelaars en onderzoekers hebben we ook voorbeeldcode opgenomen, zodat je deze modellen snel zelf kunt uitproberen.

Als je meer wilt leren over de basis van deze modellen, bekijk dan zeker onze Image Processing in Python skill track.

1. Gemini 2.5 Pro

Gemini 2.5 Pro is Google's meest geavanceerde AI-model en voert momenteel de LMArena- en WebDevArena-ranglijsten aan voor zowel visuele als coderingstaken. Het is ontworpen voor complex redeneren en begrip over tekst, afbeeldingen, audio en video.

Wat vision-language-capaciteiten betreft, behoort het tot de topmodellen op het Open LLM-leaderboard. Gemini 2.5 Pro kan afbeeldingen en video's interpreteren, gedetailleerde en contextbewuste beschrijvingen genereren en vragen beantwoorden over visuele content.

Bron: ‎Google Gemini

Je kunt Gemini 2.5 Pro gratis gebruiken via de Gemini-webapp op gemini.google.com/app of via Google AI Studio.

Voor ontwikkelaars is Gemini 2.5 Pro ook beschikbaar via de Gemini API, Vertex AI en de officiële Python-SDK, zodat je de vision-language-functies eenvoudig in je eigen apps of workflows kunt integreren.

Voorbeeldgebruik:

from google.genai import types

with open('path/to/image.jpg', 'rb') as f:
      image_bytes = f.read()

  response = client.models.generate_content(
    model='gemini-2.5-pro',
    contents=[
      types.Part.from_bytes(
        data=image_bytes,
        mime_type='image/jpeg',
      ),
      'Explain the image.'
    ]
  )
print(response.text)

2. InternVL3-78B

InternVL3 is een geavanceerde serie multimodale large language models (MLLM's) die zijn voorganger InternVL 2.5 overtreft. Het blinkt uit in multimodale perceptie en redeneren en heeft verbeterde mogelijkheden, waaronder toolgebruik, GUI-agents, industriële beeldanalyse en 3D-visieperceptie.

Het InternVL3-78B-model gebruikt specifiek InternViT-6B-448px-V2_5 voor zijn visiecomponent en Qwen2.5-72B voor zijn taalcomponent. Met in totaal 78,41 miljard parameters behaalde InternVL3-78B een score van 72,2 op de MMMU-benchmark, goed voor een nieuwe state-of-the-art onder open-source MLLM's. De prestaties zijn competitief met die van toonaangevende propriëtaire modellen.

Bron: OpenGVLab/InternVL3-78B · Hugging Face

Voorbeeldgebruik:

# pip install lmdeploy>=0.7.3
from lmdeploy import pipeline, TurbomindEngineConfig, ChatTemplateConfig
from lmdeploy.vl import load_image

model = 'OpenGVLab/InternVL3-78B'
image = load_image('https://raw.githubusercontent.com/open-mmlab/mmdeploy/main/tests/data/tiger.jpeg')
pipe = pipeline(model, backend_config=TurbomindEngineConfig(session_len=16384, tp=4), chat_template_config=ChatTemplateConfig(model_name='internvl2_5'))
response = pipe(('Explain the image.', image))
print(response.text)

3. Ovis2-34B

Ovis2 is een serie multimodale large language models (MLLM's) ontwikkeld door AIDC-AI. Deze modellen zijn ontworpen om visuele en tekstuele embeddings effectief op elkaar af te stemmen. Het Ovis2-34B-model gebruikt specifiek de aimv2-1B-patch14-448 als vision-encoder en Qwen2.5-32B-Instruct als taalmodel, goed voor in totaal 34 miljard parameters. Het ondersteunt een maximale contextlengte van 32.768 tokens en gebruikt bfloat16-precisie voor efficiënte verwerking.

Ovis2-34B heeft sterke prestaties laten zien op diverse benchmarks, met de volgende resultaten:

• MMBench-V1.1: 86,6% 
• MMStar: 69,2% 
• MMMUval: 66,7% 
• MathVista: 76,1% 
• MMVet: 77,1% 
• VideoMME: 75,6% met ondertitels 

Bron: AIDC-AI/Ovis2-34B · Hugging Face

Voorbeeldgebruik:

import torch
from PIL import Image
from transformers import AutoModelForCausalLM

# load model
model = AutoModelForCausalLM.from_pretrained("AIDC-AI/Ovis2-34B",
                                             torch_dtype=torch.bfloat16,
                                             multimodal_max_length=32768,
                                             trust_remote_code=True).cuda()
text_tokenizer = model.get_text_tokenizer()
visual_tokenizer = model.get_visual_tokenizer()

# single-image input
image_path = '/data/images/example_1.jpg'
images = [Image.open(image_path)]
max_partition = 9
text = 'Describe the image.'
query = f'<image>\n{text}'



# format conversation
prompt, input_ids, pixel_values = model.preprocess_inputs(query, images, max_partition=max_partition)
attention_mask = torch.ne(input_ids, text_tokenizer.pad_token_id)
input_ids = input_ids.unsqueeze(0).to(device=model.device)
attention_mask = attention_mask.unsqueeze(0).to(device=model.device)
if pixel_values is not None:
    pixel_values = pixel_values.to(dtype=visual_tokenizer.dtype, device=visual_tokenizer.device)
pixel_values = [pixel_values]

# generate output
with torch.inference_mode():
    gen_kwargs = dict(
        max_new_tokens=1024,
        do_sample=False,
        top_p=None,
        top_k=None,
        temperature=None,
        repetition_penalty=None,
        eos_token_id=model.generation_config.eos_token_id,
        pad_token_id=text_tokenizer.pad_token_id,
        use_cache=True
    )
    output_ids = model.generate(input_ids, pixel_values=pixel_values, attention_mask=attention_mask, **gen_kwargs)[0]
    output = text_tokenizer.decode(output_ids, skip_special_tokens=True)
    print(f'Output:\n{output}')

4. Qwen2.5-VL-72B-Instruct

Qwen2.5-VL-72B-Instruct is een multimodaal large language model (MLLM) uit de Qwen-familie, ontworpen om zowel visuele als tekstuele informatie te begrijpen en te verwerken. Veel open-source MLLM-modellen zijn hierop gebaseerd, wat aangeeft dat de Qwen-modellenreeks een belangrijke rol speelt in de vooruitgang van AI-onderzoek.

Qwen2.5-VL-72B-Instruct laat sterke prestaties zien op uiteenlopende benchmarks, waaronder beeld- en videobegrip en agentfuncties. Het scoort 70,2 op de MMMUval-benchmark, 74,8 op MathVista_MINI en 70,8 op MMStar. 

Bron: Qwen/Qwen2.5-VL-72B-Instruct · Hugging Face

Voorbeeldgebruik:

# pip install qwen-vl-utils[decord]==0.0.8

from transformers import Qwen2_5_VLForConditionalGeneration, AutoTokenizer, AutoProcessor
from qwen_vl_utils import process_vision_info

# default: Load the model on the available device(s)
model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-VL-72B-Instruct", torch_dtype="auto", device_map="auto"
)
# default processer
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-72B-Instruct")




messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg",
            },
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

# Preparation for inference
text = processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)
image_inputs, video_inputs = process_vision_info(messages)
inputs = processor(
    text=[text],
    images=image_inputs,
    videos=video_inputs,
    padding=True,
    return_tensors="pt",
)
inputs = inputs.to("cuda")

# Inference: Generation of the output
generated_ids = model.generate(**inputs, max_new_tokens=128)
generated_ids_trimmed = [
    out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
]
output_text = processor.batch_decode(
    generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)

5. o3 Latest

OpenAI's o3 is een nieuw redeneermodel dat is ontworpen om in toepassingen hogere intelligentie, lagere kosten en efficiënter tokengebruik te bieden. Het vertegenwoordigt een nieuwe generatie modellen die geavanceerde redeneercapaciteiten centraal stellen. 

Dit model zet een nieuwe standaard voor taken in wiskunde, wetenschap, coderen en visueel redeneren. Op diverse vision-benchmarks presteert het beter dan zowel o4-min als o1 en het is vergelijkbaar met o3 Pro.

Bron: Introducing OpenAI o3 and o4-mini | OpenAI

Voorbeeldgebruik:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="o3-2025-04-16",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "what's in this image?"},
            {
                "type": "input_image",
                "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
            },
        ],
    }],
)

print(response.output_text)

6. GPT 4.1 (2025-04-14)

GPT-4.1 is een nieuwe familie van niet-redenerende modellen, waaronder GPT-4.1, GPT-4.1 Mini en GPT-4.1 Nano. Deze modellen presteren beter dan hun voorgangers, GPT-4o en GPT-4o Mini, op diverse benchmarks.

GPT-4.1 behoudt sterke visuele capaciteiten, met verbeteringen in het analyseren van grafieken, diagrammen en visuele wiskunde. Het blinkt uit in taken zoals objecttellen, visuele vraagbeantwoording en verschillende vormen van optische tekenherkenning (OCR). 

Bron: Introducing GPT-4.1 in the API | OpenAI

Voorbeeldgebruik:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1-2025-04-14",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "what's in this image?"},
            {
                "type": "input_image",
                "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
            },
        ],
    }],
)

print(response.output_text)

7. Claude Sonnet 4

Anthropic heeft de volgende generatie van zijn Claude-modellen geïntroduceerd: Claude 4 Opus en Claude 4 Sonnet. Deze modellen zijn ontworpen om nieuwe standaarden te zetten in coderen, geavanceerd redeneren en AI-mogelijkheden. 

Ze bieden verbeterde vision-capaciteiten waarmee gebruikers afbeeldingen kunnen begrijpen en vervolgens code kunnen genereren of informatie kunnen geven op basis van die afbeeldingen. Hoewel het in de kern een coderingsmodel is, beschikt het ook over multimodale mogelijkheden, waardoor het verschillende bestandsformaten kan begrijpen.

Als je naar de vergelijkingstabel hieronder kijkt, zie je dat Claude 4 alle topmodellen overtreft, behalve het GPT-3-model van OpenAI, vooral in visualisatie-redeneren en visuele vraagbeantwoording.

Bron: Introducing Claude 4 \ Anthropic

Voorbeeldgebruik:

import anthropic

client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "Describe this image."
                }
            ],
        }
    ],
)
print(message)

8. Kimi-VL-A3B-Thinking-2506

De Kimi-VL-A3B-Thinking-2506 is een open-source model dat een belangrijke stap vooruit betekent in multimodale AI. Het blinkt uit op multimodale redeneerbenchmarks, met indrukwekkende nauwkeurigheidsscores: 56,9 op MathVision, 80,1 op MathVista, 46,3 op MMMU-Pro en 64,0 op MMMU, terwijl de "denk-lengte" gemiddeld met 20% wordt verminderd.

Naast de redeneercapaciteiten toont de 2506-versie verbeterde algemene visuele perceptie en begrip. Het evenaart of overtreft zelfs de prestaties van non-thinking-modellen op benchmarks zoals MMBench-EN-v1.1 (84,4), MMStar (70,4), RealWorldQA (70,0) en MMVet (78,4).

Bron: MoonshotAI/Kimi-VL: Kimi-VL

Voorbeeldgebruik:

from transformers import AutoProcessor
from vllm import LLM, SamplingParams

model_path = "moonshotai/Kimi-VL-A3B-Thinking-2506"
llm = LLM(
    model_path,
    trust_remote_code=True,
    max_num_seqs=8,
    max_model_len=131072,
    limit_mm_per_prompt={"image": 256}
)

processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)

sampling_params = SamplingParams(max_tokens=32768, temperature=0.8)


import requests
from PIL import Image

def extract_thinking_and_summary(text: str, bot: str = "◁think▷", eot: str = "◁/think▷") -> str:
    if bot in text and eot not in text:
        return ""
    if eot in text:
        return text[text.index(bot) + len(bot):text.index(eot)].strip(), text[text.index(eot) + len(eot) :].strip()
    return "", text

OUTPUT_FORMAT = "--------Thinking--------\n{thinking}\n\n--------Summary--------\n{summary}"

url = "https://huggingface.co/spaces/moonshotai/Kimi-VL-A3B-Thinking/resolve/main/images/demo6.jpeg"
image = Image.open(requests.get(url,stream=True).raw)

messages = [
    {"role": "user", "content": [{"type": "image", "image": ""}, {"type": "text", "text": "What kind of cat is this? Answer with one word."}]}
]
text = processor.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt")

outputs = llm.generate([{"prompt": text, "multi_modal_data": {"image": image}}], sampling_params=sampling_params)
generated_text = outputs[0].outputs[0].text

thinking, summary = extract_thinking_and_summary(generated_text)
print(OUTPUT_FORMAT.format(thinking=thinking, summary=summary))

9. Gemma-3-27b-it

Gemma 3 is een familie van multimodale AI-modellen, ontwikkeld door Google, die zowel tekst- als beeldinvoer kan verwerken om tekstoutput te produceren. Deze modellen zijn beschikbaar in verschillende groottes: 1B, 4B, 12B en 27B, afgestemd op uiteenlopende hardware- en prestatie-eisen.

De grootste variant, Gemma 3 27B, heeft indrukwekkende prestaties laten zien in evaluaties van menselijke voorkeuren en overtreft zelfs grotere modellen zoals Llama 3-405B en DeepSeek-V3. 

De modellen laten sterke capaciteiten zien op diverse benchmarks. Met name op multimodale taken scoren ze opvallend goed op benchmarks als COCOcap (116), DocVQA (85,6), MMMU (56,1) en VQAv2 (72,9).

Bron: Open VLM Leaderboard

Voorbeeldgebruik:

# pip install accelerate

from transformers import AutoProcessor, Gemma3ForConditionalGeneration
from PIL import Image
import requests
import torch

model_id = "google/gemma-3-27b-it"

model = Gemma3ForConditionalGeneration.from_pretrained(
    model_id, device_map="auto"
).eval()

processor = AutoProcessor.from_pretrained(model_id)

messages = [
    {
        "role": "system",
        "content": [{"type": "text", "text": "You are a helpful assistant."}]
    },
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"},
            {"type": "text", "text": "Describe this image in detail."}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt"
).to(model.device, dtype=torch.bfloat16)

input_len = inputs["input_ids"].shape[-1]

with torch.inference_mode():
    generation = model.generate(**inputs, max_new_tokens=100, do_sample=False)
    generation = generation[0][input_len:]

decoded = processor.decode(generation, skip_special_tokens=True)
print(decoded)

10. Llama-3.2-90B-Vision-Instruct

Het Llama 3.2 90B Vision Instruct-model is een geavanceerd multimodaal large language model ontwikkeld door Meta. Het is ontworpen voor taken zoals visuele herkenning, beeldredeneren en ondertiteling (captioning). 

Llama 3.2 90B Vision Instruct is gebaseerd op de tekst-only versie Llama 3.1 en bevat een apart getrainde vision-adapter, waarmee het zowel afbeeldingen als tekst als invoer kan verwerken en nauwkeurige tekstoutput kan genereren.

Getraind op enorme schaal vergde het Llama 3.2 90B Vision-model 8,85 miljoen GPU-uren. Het toont uitzonderlijke prestaties op benchmarks zoals VQAv2 (73,6), Text VQA (73,5) en DocVQA (70,7).

Bron: llama-models

Voorbeeldgebruik:

import requests
import torch
from PIL import Image
from transformers import MllamaForConditionalGeneration, AutoProcessor

model_id = "meta-llama/Llama-3.2-90B-Vision-Instruct"

model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
processor = AutoProcessor.from_pretrained(model_id)

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg"
image = Image.open(requests.get(url, stream=True).raw)

messages = [
    {"role": "user", "content": [
        {"type": "image"},
        {"type": "text", "text": "If I had to write a haiku for this one, it would be: "}
    ]}
]
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(
    image,
    input_text,
    add_special_tokens=False,
    return_tensors="pt",
).to(model.device)

output = model.generate(**inputs, max_new_tokens=30)
print(processor.decode(output[0]))

Visueel redeneren met grafieken is ook de kracht van Meta's nieuwste model, Muse Spark.

Tot slot

Vision-language-modellen veranderen fundamenteel hoe we omgaan met visuele en tekstuele informatie, met opmerkelijke nauwkeurigheid en flexibiliteit in uiteenlopende sectoren. Deze modellen combineren naadloos computer vision en natural language processing, waardoor nieuwe toepassingen mogelijk worden van geavanceerde objectdetectie tot intuïtieve visuele assistenten.

Als privacy en veiligheid topprioriteiten zijn voor jouw use case, raad ik je sterk aan om open-source vision-language-modellen te verkennen. Door deze modellen lokaal te draaien houd je volledige controle over je data, ideaal voor gevoelige omgevingen. Open-source VLM's zijn bovendien zeer aanpasbaar; de meeste kun je met slechts een paar honderd voorbeelden fijnregelen voor uitstekende, op jouw behoeften afgestemde resultaten.

Propriëtaire modellen bieden daarentegen betrouwbare en kosteneffectieve toegang tot state-of-the-art mogelijkheden. Ze zijn doorgaans zeer nauwkeurig en zijn met slechts een paar regels code in je workflow te integreren, waardoor ze ook toegankelijk zijn voor teams zonder diepe AI-expertise.

Als je meer wilt leren over vision-language-modellen, bekijk dan zeker deze resources: 

• Image Processing in Python: Praktische training in essentiële beeldbewerkingstechnieken zoals manipulatie, analyse en feature-extractie.
• Deep Learning for Images with PyTorch:  Hands-on ervaring met convolutionele neurale netwerken (CNN's), transfer learning en het ontwikkelen van eigen vision-modellen.
• Natural Language Processing in Python: Skill track over het verwerken en analyseren van tekstdata, cruciaal voor multimodale toepassingen die NLP en computer vision combineren.