QWQ (32B)

QWQ implements scaled reinforcement learning fine-tuning on top of a pretrained transformer foundation to enable explicit reasoning and chain-of-thought generation. The model learns to decompose complex problems into intermediate reasoning steps before producing final answers, with RL training optimizing for correctness on hard reasoning tasks. This differs from standard instruction-tuned models by explicitly training the reasoning process itself rather than just the output.

QWQ demonstrates enhanced capability on mathematical reasoning tasks through its RL-tuned reasoning process, enabling it to handle multi-step algebra, geometry, and calculus problems. The model generates symbolic intermediate steps and validates logical consistency across reasoning chains. Performance is claimed to be significantly enhanced on 'hard problems' compared to base language models, though specific benchmark scores are not published.

QWQ is accessible via Ollama's Python and JavaScript SDKs, providing language-native bindings for model inference without direct HTTP calls. The SDKs handle serialization, streaming, and error handling, exposing a simple API for chat completions and streaming responses. This enables integration into Python data science workflows and JavaScript web applications.

QWQ supports streaming responses via Server-Sent Events (SSE), enabling real-time token-by-token output as the model generates text. The `/api/chat` endpoint with `stream: true` returns newline-delimited JSON events, each containing partial response content. This allows applications to display output incrementally without waiting for full completion, improving perceived latency.

QWQ inference supports adjustable parameters including temperature, top_p (nucleus sampling), top_k (top-k sampling), and num_predict (max output tokens). These parameters control randomness, diversity, and output length without retraining. Temperature scales logits before sampling; top_p and top_k filter the sampling distribution; num_predict caps generation length. This enables fine-tuning model behavior for different use cases.

QWQ supports standard chat completion API with role-based message formatting (system, user, assistant), enabling multi-turn conversations where reasoning context persists across exchanges. The model maintains conversation history within the 40K token window and can reference previous reasoning steps when answering follow-up questions. Integration via Ollama's REST API at `/api/chat` endpoint provides standard OpenAI-compatible message formatting.

QWQ runs entirely on local hardware via Ollama, exposing a REST API at `http://localhost:11434/api/chat` for inference without network round-trips. The model is deployed as a 20GB quantized artifact (format unspecified, likely GGUF) that loads into VRAM and serves requests with sub-second time-to-first-token for typical hardware. This eliminates cloud API dependency, rate limiting, and data transmission overhead.

QWQ exposes its inference through Ollama's OpenAI-compatible `/api/chat` endpoint, accepting standard message arrays with role/content fields and returning chat completion objects. This compatibility layer allows existing applications built for OpenAI's API to swap in QWQ with minimal code changes. The API supports streaming responses via Server-Sent Events for real-time output.

QWQ's RL-trained reasoning process enables it to handle logic puzzles, constraint satisfaction problems, and formal reasoning tasks by generating explicit logical steps and validating consistency. The model learns to identify contradictions, apply logical rules, and explore solution spaces through its reasoning chain. This capability extends beyond mathematical reasoning to include symbolic logic, set theory, and rule-based inference.

QWQ follows complex multi-step instructions by decomposing them into sub-tasks and generating reasoning for each step. The model can handle instructions with conditional logic, nested requirements, and ambiguous specifications by explicitly reasoning through interpretation and execution. This differs from standard instruction-tuned models by showing its reasoning process alongside task completion.

QWQ generates text with awareness of up to 40,000 tokens of context, enabling it to maintain coherence across long documents, multi-turn conversations, or large code files. The model uses standard transformer attention mechanisms to weight relevant context and generate continuations that respect long-range dependencies. This context window is fixed and not dynamically expandable, requiring explicit context management for longer documents.

QWQ integrates with Ollama's ecosystem of supported applications and frameworks including Claude Code, Codex, OpenCode, OpenClaw, and Hermes Agent. These integrations expose QWQ's reasoning capabilities through specialized interfaces designed for code generation, agent orchestration, and domain-specific tasks. Ollama acts as a model abstraction layer, allowing these tools to swap models without code changes.

QWQ is available for cloud-based inference through Ollama's Pro ($20/month) and Max ($100/month) subscription tiers, providing managed hosting without local hardware requirements. Cloud inference routes requests to Ollama's infrastructure, handling model loading, scaling, and availability. This option trades local control for convenience and eliminates hardware procurement.