Qwen3-VL-235B-A22B-Instruct

Qwen3-VL-235B-A22B-Instruct

The vision-language flagship of its series. Three named mechanisms, three different problems.

DeepStack: Reading More Than the Last Layer

Fuses multi-level ViT features to capture fine-grained details and sharpen image–text alignment.

The problem it solves. A vision transformer processes an image through many layers, and the conventional approach hands the language model the final layer's output. That layer holds semantics — what the image is about — and has already discarded much of what the earlier layers saw.

Early layers carry edges, texture, and small structure. Late layers carry meaning. A model reading only the last one knows what the photograph shows and has lost the fine print inside it.

DeepStack takes features from several levels at once. That is why this model reads small text in a photograph rather than describing the photograph that contains it.

Interleaved-MRoPE: Position in Three Dimensions

Full-frequency allocation over time, width, and height via robust positional embeddings, enhancing long-horizon video reasoning.

Video has three positional axes. Where something is horizontally, where it is vertically, and when it happens. A positional scheme that handles two of them well and the third as an afterthought produces a model that describes frames rather than reasoning across them.

Full-frequency allocation across all three is the fix, and Qwen name long-horizon video reasoning as what it enables — reasoning that spans a long clip rather than summarising a few sampled frames.

Text–Timestamp Alignment: Answering "When"

Moves beyond T-RoPE to precise, timestamp-grounded event localization.

The distinction is the useful part. Most video models answer "what happens in this video." This one is built to answer "at what second does this happen."

That changes what you can build. A searchable video archive where a query returns a timestamp. A compliance check that names the moment. A support tool that jumps to the point in a screen recording where the error appeared.

Localisation rather than description — and the card marks it as an explicit step past the previous generation's approach.

OCR Built for Photographs

32 languages, up from 19. And the robustness claims are specific about conditions rather than about accuracy:

Low light. Blur. Tilt.

Those are the conditions of a photograph taken by a person, not the conditions of a scan. A receipt photographed on a table, an invoice shot at an angle, a sign captured in a dim room — the inputs a real application receives rather than the ones a benchmark supplies.

Also named: better handling of rare and ancient characters, better handling of jargon, and improved long-document structure parsing.

That last one matters for anything document-shaped. Reading the characters is one problem; understanding that a page has a header, a table, three columns, and a footnote is a different one, and it is what turns OCR output into structured data.

Text Understanding on Par With Pure LLMs

A claim worth reading carefully, because it addresses a known trade.

Seamless text–vision fusion for lossless, unified comprehension.

Vision-language models frequently lose text capability relative to the language model they were built from. The vision training pulls the model toward describing images, and pure-text reasoning suffers.

Qwen's claim is that this one does not. Which, if it holds on your workload, means one model rather than two — and the test is straightforward: run a text-only task you currently send elsewhere and compare.

Architecture

A Mixture-of-Experts vision-language model, sharing its backbone with the 235B text model in the same generation.

The family spans dense and MoE architectures from edge to cloud, with Instruct and reasoning-enhanced Thinking editions at each size.

This is the Instruct edition. It answers directly. The Thinking edition is a separate model for work where deliberation over an image or a video earns its cost.

Specifications

An official FP8 checkpoint is published, alongside an official GGUF repository and community AWQ and extended-context builds.

A 1M-context community build exists for work beyond the native window.

Capabilities

Using Qwen3-VL on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: Qwen/Qwen3-VL-235B-A22B-Instruct

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="Qwen/Qwen3-VL-235B-A22B-Instruct",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=1024,
)

print(response.choices[0].message.content)

Node.js

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    model: "Qwen/Qwen3-VL-235B-A22B-Instruct",
    messages: [{ role: "user", content: "Hello world!" }],
    max_tokens: 1024,
  });

  console.log(response.choices[0].message.content);
}

main();

cURL

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-VL-235B-A22B-Instruct",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

Reading a Document Photograph

The workload DeepStack and the OCR robustness exist for.

import base64

with open("invoice_photo.jpg", "rb") as handle:
    encoded = base64.b64encode(handle.read()).decode("utf-8")

response = client.chat.completions.create(
    model="Qwen/Qwen3-VL-235B-A22B-Instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{encoded}"}},
                {
                    "type": "text",
                    "text": (
                        "Transcribe this invoice. Preserve the structure: header fields, line-item "
                        "table with one row per item, and totals. Report the currency exactly as "
                        "printed. Mark anything you cannot read cleanly as unreadable rather than "
                        "reconstructing it."
                    ),
                },
            ],
        }
    ],
    max_tokens=8192,
)

Send the photograph as taken. Do not deskew it, do not brighten it, do not pre-process it. The model is documented as robust to low light, blur, and tilt — and a correction applied beforehand can remove information rather than add it.

Ask for structure, not just text. Long-document structure parsing is a named improvement, and the difference between a wall of characters and a table with rows is what makes the output usable.

Requiring "unreadable" over reconstruction is the instruction that keeps a guessed digit out of your accounting system. A reconstructed amount and a transcribed one look identical once they are text.

Locating an Event in a Video

Where timestamp alignment is the capability rather than a side effect.

response = client.chat.completions.create(
    model="Qwen/Qwen3-VL-235B-A22B-Instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "video_url", "video_url": {"url": "https://example.com/session.mp4"}},
                {
                    "type": "text",
                    "text": (
                        "At what timestamp does the error dialog first appear on screen? Give the "
                        "time in seconds and describe what the user did immediately before it. If "
                        "no error dialog appears, say so."
                    ),
                },
            ],
        }
    ],
    max_tokens=4096,
)

Ask "when", not "what". A summary is what any video model produces; a timestamp is what this one was built to produce, and framing the question around localisation uses the capability.

Include an out. "If no error dialog appears, say so" — without it, a model asked to find something will find something.

Video consumes input tokens rapidly. A 262,144-token window fills faster than a minute count suggests, and measuring one short clip before processing an archive is the difference between a pipeline that runs and one that fails mid-file.

Multiple Images in One Prompt

import base64

def encode(path: str) -> str:
    with open(path, "rb") as handle:
        return base64.b64encode(handle.read()).decode("utf-8")


content = []
for index, path in enumerate(["page_1.jpg", "page_2.jpg", "page_3.jpg"], start=1):
    content.append({"type": "text", "text": f"Page {index}:"})
    content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{encode(path)}"}})

content.append({
    "type": "text",
    "text": (
        "These are consecutive pages of one contract. Identify every clause that appears on one "
        "page and is contradicted on another. Name both pages and quote both clauses."
    ),
})

response = client.chat.completions.create(
    model="Qwen/Qwen3-VL-235B-A22B-Instruct",
    messages=[{"role": "user", "content": content}],
    max_tokens=16384,
)

Labelling each image before it appears gives the model something to cite. "Page 2" in an answer is verifiable; "the second image" is ambiguous once the answer is separated from the request.

Cross-page contradiction is the task a 262,144-token window justifies. A conflict between page one and page eleven is invisible to any pipeline that reads pages one at a time.

It Answers Directly

This is the Instruct edition — no reasoning blocks, no thinking mode, no reasoning_content field.

Three consequences.

max_tokens covers the answer alone. Nothing shares it, which matters on a model where a full document transcription is already a large output.

Latency tracks input and output size, not how hard the model judged the image. On a batch pipeline that predictability is what makes throughput calculable.

And a genuinely hard visual question gets a direct answer rather than a worked one. The Thinking edition in this family exists for those, and it is a separate model rather than a parameter.

Self-Hosting

The model class is Qwen3VLMoeForConditionalGeneration — distinct from the text models in this generation, and a common source of loading errors when the wrong class is used.

Transformers built from source was required at release; a specific version has since shipped. Check the version constraint before assuming an existing installation works.

Enable flash attention 2. Qwen recommend it explicitly for acceleration and memory saving, especially in multi-image and video scenarios — which is exactly where this model is used.

Enable expert parallelism. Community reference commands set it explicitly on the MoE builds.

Out-of-memory is the common failure, and the fix is reducing context length. Community configurations default to 32,768 rather than the full figure, which tells you how often that comes up.

Official builds: FP8 and GGUF from Qwen, with community AWQ, extended-context, and aggressive quantisations down to 2-bit.

Where It Fits

Document photography — invoices, receipts, forms, contracts captured by phone rather than scanned, across 32 languages.

Video search and event localisation, where a timestamp is the answer.

Screen recording analysis, for support tooling and QA.

Multi-page document review at 262,144 tokens.

Multilingual OCR at scale, including rare characters and domain jargon.

Unified text and vision work, if the text-parity claim holds on your workload — one model where you currently run two.

Not for deliberation over images. The Thinking edition is a different model.

Not for image generation. It reads; it does not draw.

Practical Notes

Send photographs as taken — the model is built for low light, blur, and tilt.

Ask for document structure, not just characters.

Require "unreadable" rather than reconstruction on anything that reaches a system of record.

Ask video questions as "when", not "what".

Label images in multi-image prompts so the answer can cite them.

Measure video token consumption on a short clip before scaling.

Test a text-only task against it before maintaining a second model for text.

If self-hosting: the MoE class, flash attention 2, expert parallelism, and reduced context on OOM.

Limitations

No thinking mode. The Instruct edition answers directly; the Thinking edition is a separate model.

Text output only. Three input modalities, one output modality.

Video fills the context quickly. 262,144 tokens is generous and a long clip will reach it.

OCR covers 32 languages. Others are outside the documented capability.

Twenty-two billion active parameters is the compute ceiling per token, whatever the 235 billion total suggests.

235 billion parameters must be loaded even though 22 billion run per token — the MoE saving is in compute, not memory.

Out-of-memory at full context is the documented failure mode, with reduced context as the fix.

A distinct model class from the text models in this generation. Loading it with the wrong class fails.

OCR robustness is not OCR infallibility. Low light, blur, and tilt are handled better, not perfectly — and a confidently transcribed wrong digit looks exactly like a correct one.