A working review of VibeThinker-3B, WeiboAI's 3B open reasoning model. What it nails on math and code, where its narrow scope shows, and who it actually fits.
VibeThinker-3B is one of the most impressive small models of 2026: a 3-billion-parameter open reasoner from WeiboAI that reports frontier-class scores on competition math and coding while running on a single GPU, under the MIT license. Judged as what it is — a verifiable-reasoning model — it is excellent and genuinely notable. It is also deliberately narrow: tuned for checkable answers, not trained for tool-calling or general writing, and it generates no media and publishes nothing. Score it high for reasoning-per-parameter and openness; look elsewhere if you came to produce and ship content.
Most coverage of VibeThinker-3B is some version of the same headline — "tiny model beats giant models" — pasted over a benchmark table. This review is not that. We build a content engine and we read model cards for a living, so the goal is to tell you what VibeThinker is genuinely good at, where its scope honestly stops, and — because people arrive at this question sideways — whether a 3B model that aces math olympiads can do anything for a content operation.
Short version up top: VibeThinker-3B is a landmark small model. Released by WeiboAI (Sina Weibo's AI team) in June 2026 under the MIT license and built on a Qwen2.5 3B base, it reports 94.3 on AIME26, 89.3 on HMMT25, 80.2 Pass@1 on LiveCodeBench v6, and a 96.1% acceptance rate on unseen LeetCode contests. Its technical report positions those numbers as competitive with frontier models many times its size on verifiable reasoning. For reasoning-per-parameter, that is a remarkable result, and the training recipe behind it — the Spectrum-to-Signal pipeline of curriculum fine-tuning plus reinforcement learning — is a real contribution.
The honest catch is scope, and it is sharper than for a general LLM. VibeThinker is tuned for problems with a checkable answer — math, code, STEM — and WeiboAI states plainly that it was not trained on tool-calling or agent-based programming data. It is not pitched as a general chat model, it writes no brand copy, and it renders no images, video, or audio. None of that is a flaw; it set out to be a focused reasoner, not a finished application. But it is the thing to understand before you decide it fits a workflow.
This review covers what VibeThinker actually is in 2026, how its reasoning and openness hold up, where it is strong, where it is honestly the wrong tool, and who should use it versus who should keep looking.
VibeThinker-3B is an open-weight large language model from WeiboAI with 3 billion parameters, built on a Qwen2.5 3B base (the Qwen2.5-Coder-3B model) and released on Hugging Face under the permissive MIT license. It is a verifiable-reasoning model: trained to solve math, code, and STEM problems whose answers can be graded as correct, rather than to chat broadly or write creatively. Its June 2026 technical report ("Exploring the Frontier of Verifiable Reasoning in Small Language Models") details the method WeiboAI calls the Spectrum-to-Signal Principle — a curriculum-based, two-stage supervised fine-tuning pass that teaches a broad spectrum of valid reasoning paths, then a reinforcement-learning stage (a GRPO variant named MaxEnt-Guided Policy Optimization, or MGPO) that amplifies the correct reasoning signal using verifiable rewards, followed by offline self-distillation. What sets it apart is the size-to-skill ratio: it reaches scores usually associated with models hundreds of times larger on the specific benchmarks it targets, while remaining small enough to run on a single consumer GPU. What it does not do is anything beyond verifiable reasoning. WeiboAI notes it was not trained on tool-calling or agent-based programming data, and it produces only text reasoning — no images, video, audio, captioning, design, or publishing. It continues the approach of the team's earlier, smaller VibeThinker-1.5B.
The clearest fit is anyone who needs strong reasoning on problems with a checkable answer at low cost: researchers and engineers running math, code, or STEM tasks locally; builders who want a small, permissively licensed reasoning component to fine-tune and embed without vendor lock-in; and teams that want capable inference on their own hardware with no API bill. It is also a compelling object of study for anyone interested in how far small models can be pushed with the right post-training. It is the wrong tool for someone whose actual output is published content — video, images, carousels, social posts — because producing and distributing that content is entirely outside what the model does, and it is narrower even than a general assistant: no tool-calling, no agentic workflows, no copywriting focus. Non-technical users who want a hosted, log-in-and-go experience should also look elsewhere.
| Dimension | Score | Why |
|---|---|---|
| Verifiable reasoning (competition math) | 4.7 / 5 | Reported 94.3 on AIME26 and 89.3 on HMMT25 at just 3B — a standout result for the size on hard, checkable problems. |
| Coding (well-specified tasks) | 4.5 / 5 | 80.2 Pass@1 on LiveCodeBench v6 and a 96.1% LeetCode acceptance rate. Strong on self-contained problems; not an agentic coding tool. |
| Efficiency / reasoning-per-parameter | 4.9 / 5 | Frontier-class benchmark scores from a model that runs on a single consumer GPU is the headline, and it earns it. |
| Openness & license | 4.6 / 5 | MIT-licensed open weights on Hugging Face with a detailed technical report. Commercial use and self-hosting with no fee to the model. |
| General capability / breadth | 2.8 / 5 | Tuned for checkable answers; not a general chat model, not trained for tool-calling or agentic work. Narrow by design. |
| Ease of use / accessibility | 3.4 / 5 | Small enough to run locally, but it is still a raw model to operate — not a hosted, log-in-and-go product. |
| Content / social media production | 1.0 / 5 | Not the product. No image, video, audio, captions, copywriting focus, or design output. |
| Multi-platform publishing | 1.0 / 5 | VibeThinker produces text reasoning; it does not post. No scheduler, no platform integration. |
VibeThinker-3B has no license price. The weights are free under MIT, so the cost question is "what does it cost to run" — and because it is only 3B parameters, the answer is unusually low. It runs on a single consumer GPU, which means a researcher or small team can self-host high-quality reasoning without the GPU bill that larger open models like a 70B demand, and without per-token API fees. If you would rather not run hardware at all, hosted inference providers can serve it at their own per-token pricing.
For the reasoning use cases VibeThinker targets, that economic model is close to ideal: frontier-class benchmark performance at a fraction of the usual hardware footprint is exactly the value proposition, and MIT licensing removes any per-seat or per-token drag on the model itself. The catch is the familiar one — "free model" is not "free outcome." The total cost of turning VibeThinker into anything user-facing is the application you build around it.
The honest framing on value is that VibeThinker is priced like what it is: efficient open reasoning infrastructure. It is not priced or built as a content tool, and no amount of inference budget adds writing voice, media rendering, or publishing. If your spend is meant to produce and distribute content, you are comparing the wrong line item.
| Use case | Fit | Why |
|---|---|---|
| Local reasoning on math, code, and STEM problems | Strong | This is the model's entire purpose, and its reported scores at 3B are remarkable on exactly these checkable tasks. |
| Embedding a small, open reasoning component in a product | Strong | MIT-licensed 3B weights are an efficient foundation to fine-tune and run without vendor lock-in. |
| Cheap, on-hardware inference for a small team | Strong | It runs on a single consumer GPU, so high-quality reasoning is affordable and stays on your own machine. |
| General-purpose chat and broad knowledge tasks | Weak | It is tuned for verifiable answers, not breadth, and is not pitched as a general assistant. |
| Tool-calling or agentic automation | Weak | WeiboAI states it was not trained on tool-calling or agent-based programming data. |
| Writing on-brand copy, captions, or scripts | Weak | A reasoning model tuned for correctness is not built for voice, and content has no single right answer to optimize. |
| Producing video, images, or carousels for social | Weak | No media generation of any kind. Entirely outside VibeThinker's scope. |
| Scheduling and publishing across platforms | Weak | No publishing layer and no scheduler. It produces text reasoning, not posts. |
If you arrived at this review wondering whether VibeThinker-3B can run your content operation, the honest answer is no — and that is a category point, not a criticism. VibeThinker is a reasoning model: efficient, open, and excellent at problems with a checkable answer. It has no writing-voice layer, no renderer, no design system, and no scheduler, because it was never meant to be a content tool — and unlike a general LLM it was not even trained for tool-calling. Scoring it as a content engine would be unfair to a model that is genuinely outstanding at its actual job.
Kompozy sits at the layer above, and the two are complementary rather than rival. Where VibeThinker stops at verifiable reasoning, Kompozy turns an idea — or the conclusion of an analysis — into 18 content formats: persona and avatar video, carousels, quote cards, infographics, blogs, newsletters, and platform-native posts, held to one brand voice through a Persona Brief and scheduled across nine platforms plus email and blog. It runs that generation on managed Claude and OpenAI models, which are the right tools for open-ended writing, so there is nothing to operate. A practical pairing: run VibeThinker locally to reason over your performance data or pressure-test a plan, then let Kompozy produce and ship the content the model concluded you should make. Use VibeThinker for the reasoning it is built for, and a content engine for the content.
VibeThinker-3B is an open-weight, 3-billion-parameter reasoning model from WeiboAI (Sina Weibo's AI team), released in June 2026 under the MIT license and built on a Qwen2.5 3B base. It is tuned for verifiable reasoning — math, code, and STEM — and its technical report reports benchmark scores competitive with much larger frontier models on those specific tasks.
For cheap, local, high-quality reasoning on problems with a checkable answer — yes, it is one of the most impressive small models available, and free under MIT. It is not worth adopting for content production, because it generates no media, is not tuned for writing voice, and publishes nothing; for that you need a content engine on top.
It matches them on specific verifiable-reasoning benchmarks like AIME26 and LiveCodeBench, not across the board. WeiboAI credits its training recipe — the Spectrum-to-Signal Principle of curriculum supervised fine-tuning, MGPO reinforcement learning with verifiable rewards, and self-distillation — rather than raw scale.
No. It is a text reasoning model for math, code, and STEM, was not trained for general copywriting or tool-calling, and produces no images, video, or audio. To turn its analysis into published content you pair it with a content engine like Kompozy.
The model is free under the MIT license. Because it is only 3B parameters, it runs on a single consumer GPU, so your real cost is modest hardware for local inference — or a hosted provider's per-token pricing if you prefer not to run it yourself.
On its target benchmarks — competition math and coding — it reports scores competitive with much larger systems. But it is far narrower: no tool-calling, no agentic workflows, not a general assistant, and it trades the convenience and breadth of a closed API for openness and self-hosting.
Kompozy, without question. VibeThinker produces text reasoning on checkable problems; Kompozy generates video, images, carousels, blogs, and newsletters and publishes them across platforms. Use VibeThinker as a local reasoning layer — even to analyze what content to make — and Kompozy to produce and ship it.