
MOSS-VL is the core multimodal model series in the OpenMOSS ecosystem, dedicated to pushing the frontier of visual understanding. To tackle the challenges inherent to video understanding, our technical roadmap pursues a systematic scaling strategy along three key dimensions.
Building large-scale, high-quality multimodal datasets to drive strong generalization.
Growing model capacity to precisely capture complex vision–language associations.
Extending the temporal horizon to enable deep reasoning over long-form videos.
MOSS-VL adopts a cross-attention-based architecture that decouples visual encoding from cognitive reasoning. This architecture provides a unified backbone for offline image and video understanding. With native support for interleaved modalities, the model handles complex image and video sequences in a unified pipeline, free of heavyweight preprocessing. Continuous-stream interaction is provided separately by MOSS-VL-Realtime.
To ensure the model precisely perceives the pace and duration of events, MOSS-VL injects an absolute timestamp into every sampled frame, anchoring the reasoning process to a precise temporal reference.
Precise time markers are interleaved throughout each video. Every timestamp is wrapped in dedicated special tokens (<|time_start|> … <|time_end|>), explicitly anchoring the temporal position of every visual frame:
<|im_start|><|vision_start|> <|time_start|>0.0 seconds<|time_end|><|image_pad|> <|time_start|>1.2 seconds<|time_end|><|image_pad|> <|time_start|>2.3 seconds<|time_end|><|image_pad|> ... <|vision_end|>The video shows a dynamic scene with continuous motion...<|im_end|>
dt) available, the model can reason about the physics of motion, yielding accurate estimates of speed, acceleration, and trajectories.MOSS-VL employs a Cross-attention Rotary Position Embedding (XRoPE) tailored to its cross-attention-based vision–language architecture. This mechanism maps text tokens and video patches into a unified 3D coordinate space defined by time (t), height (h), and width (w).
To optimize cross-modal alignment, XRoPE is injected into the vision-side Keys (K) to strengthen positional awareness while leaving the Values (V) untouched, preserving feature fidelity. Meanwhile, XRoPE is applied to the text-side Queries (Q), allowing the model to retrieve information from any spatio-temporal region through direct coordinate alignment.
Below are inference examples of MOSS-VL on real video inputs. For more examples, visit our interactive demo page, or try it online in the HuggingFace Space.
MOSS-VL follows a multi-stage training approach that builds multimodal capability progressively.
MOSS-VL builds multimodal capability from scratch through a systematic four-stage pre-training pipeline:
Establishes the initial bridge between visual features and the language space. Training on large-scale image–text pairs teaches the model to associate visual concepts with their textual descriptions, while cultivating basic OCR ability to read text in images.
Expands the model's exposure to a massive, diverse multimodal corpus, broadening its grasp of world knowledge and complex scenes, and laying a solid foundation for general intelligence and high-resolution perception. Short video clips are also introduced at this stage to seed video understanding.
Comprehensively raises model quality by training on abundant high-quality perception, understanding, and reasoning data. This stage combines fine-grained image perception, complex multi-image understanding, and high-fidelity video reasoning, strengthening the model's ability to capture intricate visual details and temporal relations.
Extends the model's horizon to long-video understanding, while a carefully designed annealing strategy trains on curated top-tier multimodal data to push final performance to its peak.
On top of the pre-trained model, MOSS-VL is further refined through supervised fine-tuning (SFT) to align with human intent and fully unlock its interactive and instruction-following capabilities.
We evaluated MOSS-VL-Instruct-0708 for offline multimodal understanding across perception, video understanding, grounding, document / OCR, and reasoning. The table below reports the 0708 release alongside the previous MOSS-VL-0408 checkpoint and open-source baselines.
Scores are reported per benchmark rather than collapsed into a single aggregate. Bold red marks the best reported score in each row, and underlining marks the second best.
Swipe horizontally inside the chart to view the full benchmark.
conda create -n moss_vl python=3.12 pip -y conda activate moss_vl pip install -i https://pypi.org/simple --no-build-isolation -r requirements.txt
For more ready-to-run inference examples and demo assets, see inference/README.md. Inference supports full-modality offline queries, including text-only, single-image, multi-image, single-video, multi-video, and interleaved image–video inputs via the messages format.
offline_generateimport queue
import threading
import torch
from transformers import AutoModelForCausalLM, AutoProcessor
checkpoint = "/path/to/dummy-checkpoint"
processor = AutoProcessor.from_pretrained(
checkpoint,
trust_remote_code=True,
frame_extract_num_threads=1,
)
model = AutoModelForCausalLM.from_pretrained(
checkpoint,
trust_remote_code=True,
device_map="auto",
torch_dtype=torch.bfloat16,
attn_implementation="flash_attention_2",
)
query = {
"messages": [
{
"role": "user",
"content": [
{"type": "image", "image": "path/to/example.jpg"},
{"type": "text", "text": "Describe this image."},
],
}
],
"media_kwargs": {},
"generate_kwargs": {
"max_new_tokens": 256,
"do_sample": False,
"vision_chunked_length": 64,
},
}
input_queue = queue.Queue()
output_queue = queue.Queue()
worker = threading.Thread(
target=model.offline_generate,
args=(processor, input_queue, output_queue),
kwargs={"vision_chunked_length": 64},
daemon=True,
)
worker.start()
input_queue.put(query)
text_chunks = []
while True:
item = output_queue.get()
if item in {"<|round_start|>"}:
continue
if item == "<|round_end|>":
break
text_chunks.append(item)
print("".join(text_chunks))
input_queue.put({"stop_offline_generate": True})
worker.join()
For simple batch offline inference, you can also use offline_batch_generate directly:
offline_batch_generateimport torch
from transformers import AutoModelForCausalLM, AutoProcessor
checkpoint = "/path/to/dummy-checkpoint"
processor = AutoProcessor.from_pretrained(
checkpoint,
trust_remote_code=True,
frame_extract_num_threads=1,
)
model = AutoModelForCausalLM.from_pretrained(
checkpoint,
trust_remote_code=True,
device_map="auto",
torch_dtype=torch.bfloat16,
attn_implementation="flash_attention_2",
)
queries = [
{
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": "Describe sample A."}],
}
],
"media_kwargs": {},
"generate_kwargs": {"max_new_tokens": 256, "do_sample": False},
},
{
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": "Describe sample B."}],
}
],
"media_kwargs": {},
"generate_kwargs": {"max_new_tokens": 256, "do_sample": False},
},
]
with torch.no_grad():
result = model.offline_batch_generate(
processor,
queries,
vision_chunked_length=64,
)
texts = [item["text"] for item in result["results"]]
print(texts)
We provide a lightweight SFT fine-tuning framework built on HuggingFace transformers.Trainer, supporting both full-parameter training and LoRA, with independent control over whether the vision encoder, language model, and LM head participate in training.
# Full-parameter SFT (vision encoder frozen by default) bash finetune/scripts/run_sft.sh # LoRA SFT pip install -i https://pypi.org/simple peft bash finetune/scripts/run_sft_lora.sh
Training data uses a JSON structure compatible with the inference query format, requiring only an extra response field:
[
{
"prompt": "Describe this image.",
"response": "A beautiful landscape painting surrounded by mountains.",
"images": ["path/to/image.jpg"],
"videos": []
}
]
Multi-turn dialogue formats are also supported; see finetune/README.md for full documentation.
| Model | 🤗 Download | 🤖 ModelScope |
|---|---|---|
| MOSS-VL-Base-0408 | HuggingFace | ModelScope |
| MOSS-VL-Instruct-0408 | HuggingFace | ModelScope |
| MOSS-VL-Base-0708 | HuggingFace | ModelScope |
| MOSS-VL-Instruct-0708 | HuggingFace | ModelScope |
| MOSS-VL-Realtime | HuggingFace | ModelScope |
SGLang officially supports MOSS-VL. For SGLang-based deployment and serving instructions, see sglang/README.md.
swift infer and LoRA or full-parameter fine-tuning with swift sft. See PR #9944.We sincerely thank NVIDIA for the Megatron-LM framework and the Qwen team for the powerful Qwen series of language models; these outstanding open-source works laid a solid foundation for our training infrastructure and core language model. We are also deeply grateful to the SGLang team for the high-performance SGLang inference and serving framework, which provides vital support for the efficient deployment of MOSS-VL.
@misc{mossvl,
title = {MOSS-VL Technical Report},
author = {Wang, Pengyu and Tan, Chenkun and Zhou, Shaojun and Zhou, Qirui and Chen, Yanxin and He, Xingyang and Zeng, Huazheng and Cheng, Jijun and Wang, Chenghao and Qian, Xiaomeng and Wang, Pengfei and Huang, Zhan and Gao, Shanqing and Huang, Wei and Cao, Longjun and Ran, Wu and Liu, Jie and Zhu, Changtai and Wang, Hongkai and Tian, Yixian and Liu, Chenghao and Ye, Zhen and Wang, Xinghao and Jiang, Botian and Feng, Guoguo and Fei, Zhaoye and Li, Ruixiao and Chen, Mingshu and Gao, Yang and Cheng, Qinyuan and Li, Shimin and Qiu, Xipeng},
year = {2026},
eprint = {2608.15045},
archivePrefix = {arXiv},
primaryClass = {cs.CV},
url = {https://arxiv.org/abs/2608.15045}
}