WeChat open-sources WeVisOne-VL: one small vision model to find, count, read and cut out

What's going on

The vision team at WeChat, the messaging platform run by Chinese tech giant Tencent, has open-sourced a new image model called WeVisOne-VL. The goal is to fold all the small, repetitive steps of image work into one model. It can find a specific person, count the goods on a shelf, read the text on a package and cut out the main subject with a transparent background.

There are two variants with 2 and 4 billion parameters, so both are small enough for ordinary hardware. A report on the Chinese product platform woshipm.com (author "亨亨", channel "产品变量") says the model gets 32 percent more answers right on the test dataset than comparable models. That figure comes from the official materials and hasn't been independently verified yet. You can try both sizes in your browser without installing anything:

• 2B version: huggingface.co/spaces/hugging-apps/wevisone-vl-2b
• 4B version: huggingface.co/spaces/hugging-apps/wevisone-vl-4b

Code, weights and developer docs are at github.com/Tencent/WeVisOne-VL.

The problem: lots of specialist tools for small jobs

The author points to two weak spots in today's image workflows. First, most vendors are focused on big general-purpose models, so specialist models for these niche tasks are improving slowly. Second, there's a tool for every individual task, but in a real workflow you still have to switch between programs, select the object again each time and check the results by hand.

WeVisOne-VL returns different outputs depending on the task: positions as coordinates, counts, recognized text, segmentation masks (outlines that separate an object from the background) and alpha mattes for cutouts. The developers say they trained it on more than 100 million annotated images and about 3.6 billion bounding boxes.

What the hands-on test shows

The author tried the model through the online demo:

• Finding people: Given a photo of a children's band, the model was asked to find "boys holding a microphone". It returned two boxes, exactly around the two boys holding microphones in the middle of the frame. To get there, it had to put together the object, the person and the action of "holding".
• Recognizing what isn't there: In the same image, it was asked for "boys holding a violin". There's no violin in the picture, and the model replied with <ref>boys holding violin</ref><box>none</box>. It didn't mistake a guitar for a violin. The author stresses that this is harder than recognizing an object, because many models mark some region even when there's nothing to find. In day-to-day work, that leads to wrong crops, wrong counts and wrong data being passed along.
• Counting: On a photo of a chessboard, the model was asked to count the white pieces. It returned 16 boxes and a total of 16, which is correct. Because every piece is marked individually, you can easily check whether anything was missed, counted twice or mixed up. In an official example, a fruit stand with apples and oranges spread across several baskets, the report says almost all the comparison models got it wrong while WeVisOne-VL counted correctly.
• Text recognition (OCR): The tests covered shop signs, food packaging, receipts and information boards. The author notes that dedicated OCR models like DeepSeek-OCR, Xiaomi-OCR-0 or Baidu's Unlimited OCR 2 are strong, but they can only read text. WeVisOne-VL can also look for one specific piece of text, such as just the words "SMALL ALLEY" on a café sign.
• Segmentation: With several remote controls on a table, the model was asked to select the leftmost one and the third from the right. It traced the outlines of both correctly.
• Matting: According to the report, the model cut out chickens in a pen without mistakes, while competing models made errors. On an iceberg, it kept far more detail than methods that only work at the pixel level. The toughest case was a hot-air balloon carrying the partly hidden word "Daikin" in cursive script. Cutting it out takes text recognition, telling it apart from the other balloons and matting, all at once. The author calls the result "astonishing".

How the model works

WeVisOne-VL wasn't built from scratch. It's a further-trained version of Qwen3-VL, Alibaba's vision-language model. The pipeline has three stages:

1. Understanding: A vision encoder turns the image into features the model can compute with. These features go into the language model together with the text instruction, and the language model decides who or what is meant and where it is.
2. A unified output format: Every task is framed as structured output: object name plus box coordinates, multiple boxes or points plus a count, or text plus position. Coordinates get their own special tokens. That's why one model can handle so many tasks. They all rest on the same core skills: understand the description, pin down the object, give its position.
3. Pixel decoder: For segmentation and matting, the model emits a special <OBJ> token after each box. This token passes the object's internal representation to a decoder. The decoder reads the box and several layers of image features and computes a pixel-accurate outline or a transparency map. Matting keeps soft transitions such as fine hair or semi-transparent edges. The decoder has only about 9.6 million parameters and reuses the main model's image features, so you don't need a separate large segmentation model like SAM (Meta's "Segment Anything").

The division of labor is clear. The language part decides which object to work on, and the pixel part decides how to extract it cleanly. If the wrong object gets picked, the error is up front. If the object is right but the hair looks messy, the decoder is to blame.

Training against false detections

The team uses a "data engine" that links object descriptions, boxes, outlines and transparency data. Training ran in several stages. First the model learned the unified output format, then small objects and crowded scenes, then the pixel tasks. Finally, localization was refined with reinforcement learning, a reward-based method where the model scores points for correct results.

The "not in the image" case got targeted training. The model shouldn't mark objects that don't exist, and it shouldn't miss or confuse objects that do. To measure this, the team built its own benchmark, WeRef-Bench, which tracks among other things how often the model correctly answers "not present".

The developers name two weaknesses themselves. Complex occlusion, transparent objects and vague instructions remain hard. And the model produces its structured output directly, without visibly "thinking out loud" first (chain of thought). That makes it faster, but possibly less thorough on tricky cases.

Real-world use

The report says it's most useful for content teams and online retailers. They can pull people or products out of images by description and hand them off for layout or background swaps, filter material in image archives by position data, count stock and read details off packaging. For batch work there's an official inference package. Each call takes an image, a task type (for example matting) and a target description (for example "person"). You get back an alpha matte and an image with a transparency channel. A script can work through entire folders, or you can run it as an HTTP service inside existing systems. Your own application still has to handle orchestration, file naming and quality control.

The author also suggests letting AI agents like Claude Code or Codex call the model. The agent plans the work and searches folders, and WeVisOne-VL does the actual image work. He argues that's more precise and cheaper than having the big agent model do everything.

What you need to try it

The easiest option is the Hugging Face demos, which need no hardware of your own. The source gives no concrete hardware requirements for running it locally. As a rough estimate, the 2B variant should run on GPUs with 4 to 6 GB of VRAM, and the 4B variant should be comfortable with about 8 to 10 GB at full precision. With quantization, which stores the model's numbers at lower precision, both would need less, but it's unclear whether that's officially supported. High-resolution images need more memory. Installation and system requirements are covered in the GitHub repository. The source doesn't mention ready-made Ollama or GGUF packages.

The bigger picture

WeVisOne-VL reflects a trend. Instead of ever-larger general-purpose models, we're seeing small specialist models that reliably handle one clearly defined workflow. The most interesting part is getting precise object search, OCR and real matting with transparency into a model of 2 to 4 billion parameters. Until now, that usually took a vision-language model, an OCR model and SAM. The targeted training on "not present" matters a lot in practice, because false detections are one of the biggest problems in automated workflows.

Some caveats remain. The 32 percent lead and the comparison images come from the developers and their demo material. The report is partly unclear about exactly which competing models were compared. The article doesn't mention the license, so if you plan to use the model commercially, check it on GitHub. And the developers themselves admit weaknesses with occlusion, transparent objects and vague instructions.