QwQ 32B

QwQ-32B generates intermediate reasoning tokens that are visible in the output stream before producing a final answer, implementing transparent chain-of-thought reasoning through a two-stage reinforcement learning process. The model was trained with outcome-based rewards on math and coding tasks using verification servers (accuracy verifiers for math, code execution servers for testing), then fine-tuned for general capabilities using a general reward model. This approach makes the reasoning process inspectable and auditable rather than hidden in latent representations.

QwQ-32B solves mathematical problems by leveraging reinforcement learning trained with outcome-based rewards using accuracy verifiers that check solution correctness. The model was trained on math tasks where a verification system evaluates whether the final answer is correct, enabling the model to learn which reasoning paths lead to correct solutions. This approach achieves 79.5% on AIME 2024 and 96.4% on MATH-500 benchmarks, demonstrating strong performance on competition-level and standardized math problems.

QwQ-32B achieves reasoning performance comparable to much larger models (DeepSeek-R1 at 671B parameters) through efficient reinforcement learning training on robust foundation models. The model uses outcome-based rewards and verification servers to scale reasoning capability without proportional parameter increases. This approach demonstrates that RL-based training can achieve reasoning efficiency gains, enabling competitive performance at 32B parameters.

QwQ-32B provides documented performance metrics on standardized reasoning benchmarks including AIME 2024 (79.5%), MATH-500 (96.4%), and LiveCodeBench, enabling quantitative comparison with other reasoning models. These benchmark results are publicly reported and provide concrete evidence of reasoning capability on well-defined problem sets. The benchmarks cover mathematical reasoning, coding, and general problem-solving domains.

QwQ-32B generates code solutions and verifies them through reinforcement learning trained with outcome-based rewards using code execution servers that run test cases against generated code. The model learns to produce code that passes execution tests by receiving feedback from actual test case runs, enabling it to refine solutions based on execution results. This approach achieves strong performance on LiveCodeBench and enables the model to generate executable, tested code rather than syntactically-correct but functionally-incorrect solutions.

QwQ-32B supports agent-based reasoning where the model can use tools and adapt based on environmental feedback, enabling it to interact with external systems and refine solutions based on execution results. The model was trained with reinforcement learning to handle tool use and environmental feedback, allowing it to function as an autonomous agent that can call functions, receive results, and adjust its reasoning accordingly. This capability enables multi-step problem-solving where the model can iteratively refine solutions based on real-world feedback.

QwQ-32B follows general instructions and aligns with human preferences through a second stage of reinforcement learning training using a general reward model and rule-based verifiers. After initial math and coding-specific RL training, the model was fine-tuned with a general reward model to improve performance on diverse tasks and align with human preferences. This two-stage approach enables the model to maintain strong reasoning capabilities while also following general instructions and producing human-preferred outputs.

QwQ-32B can be deployed for inference on a single GPU using the HuggingFace Transformers library with PyTorch, enabling self-hosted reasoning applications without cloud API dependencies. The model is distributed as open-weight model files (SafeTensors format) on HuggingFace Hub and ModelScope, allowing developers to download and run the model locally with standard inference code. This approach provides full control over inference, data privacy, and eliminates API latency and quota constraints.

QwQ-32B is distributed under Apache 2.0 license as open-weight model files, allowing unrestricted commercial and non-commercial use with attribution. The model weights are publicly available on HuggingFace Hub (Qwen/QwQ-32B) and ModelScope, enabling free download and deployment without licensing restrictions. This open-source approach provides legal clarity for commercial applications and enables community contributions and fine-tuning.

QwQ-32B integrates with HuggingFace Transformers library using standard PyTorch APIs, enabling inference through familiar AutoModelForCausalLM and AutoTokenizer interfaces. The model uses standard chat template formatting for multi-turn conversations and supports device mapping for automatic GPU/CPU allocation. This compatibility enables drop-in integration with existing HuggingFace-based inference pipelines and tools.

QwQ-32B is available through Alibaba Cloud DashScope API, providing cloud-hosted inference without local GPU requirements. The API provides managed inference with automatic scaling, monitoring, and integration with Alibaba Cloud services. This option enables teams without GPU infrastructure to access reasoning capabilities through standard REST/gRPC APIs.

QwQ-32B supports multi-turn conversations using standard chat template formatting with role/content message structure, enabling natural dialogue interactions. The model applies chat templates automatically to format messages with system, user, and assistant roles, enabling multi-turn reasoning conversations. This approach enables interactive reasoning where users can ask follow-up questions and receive contextual responses.