VibeThinker-3B

VibeThinker-3B is a 3-billion-parameter dense reasoning model from WeiboAI, fine-tuned from Qwen2.5-Coder-3B and released under the MIT license. It is not a general-purpose chatbot or agent framework — it is a specialized verifiable-reasoning engine designed for math, competitive programming, and STEM problems where answers can be checked precisely. This focus is what makes it stand out: the model’s post-training pipeline (Spectrum-to-Signal) optimizes for tasks with clear correctness signals, not open-ended dialogue or tool use.

At 3B parameters, VibeThinker-3B competes with other small-to-medium reasoning models (e.g., DeepSeek-R1-Distill-Qwen-1.5B, Qwen2.5-Coder-3B-Instruct) but punches far above its weight on benchmarks. It scores 94.3 on AIME 2026, 89.3 on HMMT 2025, 70.2 on GPQA-Diamond, and 80.2 Pass@1 on LiveCodeBench v6. With claim-level reliability (CLR) test-time scaling, the AIME 2026 score jumps to 97.1 — rivaling frontier models orders of magnitude larger. This makes it a compelling option for practitioners who need strong reasoning in a package small enough to run on consumer hardware.

VibeThinker-3B is a dense transformer with 3B parameters — no mixture-of-experts, no sparse activation. This means all 3B parameters are active for every forward pass, making inference predictable in terms of VRAM and throughput. The architecture is based on Qwen2.5-Coder-3B, which uses a standard decoder-only causal attention design with RoPE (Rotary Position Embedding) and SwiGLU feedforward layers.

Context length is 65,536 tokens — unusually long for a 3B model. This is critical for multi-step reasoning problems (e.g., solving a 10-page math proof or debugging a 2,000-line code snippet). When using the model on hard benchmarks like AMOBench, WeiboAI recommends setting max_tokens to 60K–100K to allow the model enough space to think through extreme difficulty problems.

The model uses bfloat16 precision natively; 4-bit quantization (e.g., Q4_K_M via llama.cpp) reduces VRAM to roughly 2.5–3 GB while retaining most of the reasoning quality. No MoE means no routing overhead — latency is purely a function of prompt and generation length.

VibeThinker-3B excels where the answer can be verified against a ground truth — what WeiboAI calls “verifiable reasoning.” This includes:

• Mathematical reasoning: Olympiad-level competition problems (AIME, HMMT, IMO AnswerBench). The model can handle multi-step algebra, geometry, number theory, and combinatorics.
• Competitive programming: LeetCode-style algorithmic problems, especially hard (H) and extreme (E) difficulty. It scores 80.2% Pass@1 on LiveCodeBench v6 and 96.1% acceptance rate on recent unseen LeetCode contests.
• STEM reasoning: Physics, chemistry, and engineering problems that require step-by-step derivation and constraint satisfaction.
• Instruction following with explicit constraints: IFEval score of 93.4 confirms it respects formatting, length, and content restrictions — useful for generating structured reports.

What it is not for: tool-calling, autonomous coding agents, API orchestration, or general-purpose conversation. The model was intentionally not trained on function-calling or agent data. Use it for batch evaluation of challenging problems, automated grading, or as a reasoning engine in a pipeline that provides verification signals.

This is where VibeThinker-3B shines for practitioners. The 3B dense architecture fits comfortably on consumer GPUs and even some laptops.

VRAM requirements (inference):

Recommended hardware:

• Minimum: NVIDIA RTX 3060 (12 GB) — can run bfloat16 comfortably with headroom for context.
• Recommended: RTX 4090 (24 GB) — allows full 65K context at bfloat16 with fast generation.
• Apple Silicon: M4 Max (128 GB unified memory) — runs at full precision easily. M3 Pro (18 GB) can handle Q4_K_M with moderate context.
• CPU-only: Possible with llama.cpp on a modern CPU (e.g., AMD Ryzen 9) at ~1–2 tokens/sec with Q4_K_M and 64 GB RAM.

Expected tokens per second (single batch, 4090 at bfloat16): ~80–100 t/s for generation, ~150–200 t/s ingest. With Q4_K_M, expect 120–150 t/s on the same GPU.

Quickest way to start: Use Ollama. Pull the model (once it’s added to the official library) or run it directly with llama.cpp using a GGUF conversion. Example command:

1ollama run vibethinker-3b

For maximum control, download the HuggingFace transformers checkpoint and load it in your Python script:

1from transformers import AutoModelForCausalLM, AutoTokenizer
2
3model = AutoModelForCausalLM.from_pretrained("WeiboAI/VibeThinker-3B", torch_dtype="bfloat16").to("cuda")
4tokenizer = AutoTokenizer.from_pretrained("WeiboAI/VibeThinker-3B")

vs. Qwen2.5-Coder-3B-Instruct (base model):

• VibeThinker-3B is significantly stronger on math and reasoning benchmarks but weaker on general coding tasks (e.g., function calling, agentic workflows). If your workload is strictly competitive programming or math, VibeThinker is the better pick. If you need a balanced coding assistant, Qwen2.5-Coder is more versatile.

vs. DeepSeek-R1-Distill-Qwen-1.5B (similar small reasoning model):

• VibeThinker-3B has 2x parameters and dramatically higher benchmark scores (e.g., AIME 94.3 vs. ~30 for the 1.5B distill). It also supports a much longer context (65K vs. 32K). The tradeoff is VRAM: VibeThinker-3B requires ~3 GB at Q4 vs. ~1.5 GB for the 1.5B model. For those with at least an RTX 3060, VibeThinker-3B offers frontier-level reasoning in a small package.

Verifiable reasoning specialty: VibeThinker-3B deliberately sacrifices broad knowledge and conversational ability to maximize performance on tasks with clear answers. If you need a model for open-ended Q&A or creative writing, look elsewhere. If you need a reasoning copilot that can solve IMO-level problems and LeetCode hards on your local machine, this is the best option at its size.