How to Run Qwen3.8 Locally with Ollama (2026 Guide)

What Qwen3.8 Is and Which Tag to Run

Qwen3.8 is Alibaba's newest release in the Qwen3 family, a dense 27.8 billion parameter model. Dense means every one of those parameters is active on every token, unlike a mixture-of-experts design that only activates a fraction of its total parameters per token. That makes Qwen3.8 more predictable to size for hardware: whichever quantization tag you pull is the actual memory footprint during inference, with no separate "active parameters" figure to account for.

The attention design underneath mixes two mechanisms. Some layers use linear attention, which scales more efficiently with sequence length, and others use full attention, which captures longer-range dependencies more precisely. Alibaba pairs this hybrid design with a native 262,144 token (256K) context window, extendable to 1 million tokens with additional configuration. Qwen3.8 also ships as multimodal, accepting both text and image input, and thinking mode is on by default, meaning the model writes out its reasoning before producing a final answer. Two request-level parameters control this: `reasoning_effort` sets how much reasoning the model does, and `preserve_thinking` controls whether prior reasoning carries into later turns of the same conversation.

On Ollama's library, the `qwen3.8` tag holds several real quantizations:

The plain `qwen3.8` tag, the explicit `27b` tag, and `27b-q4_K_M` all point at the identical 18GB download. Ollama's library also lists a few more specialized tags, `27b-mtp-q4_K_M`/`27b-mtp-q8_0`/`27b-mtp-bf16` (multi-token prediction variants at the same sizes as their non-MTP counterparts), `27b-mxfp8` (32GB), and `27b-nvfp4` (18GB, for NVIDIA Blackwell-class GPUs with native FP4 support). The four tags in the table above cover what almost everyone running this locally actually needs.

Install Ollama and Run Your First Qwen3.8 Prompt

Getting Qwen3.8 running takes about ten minutes on a normal connection, most of it spent downloading the 18GB default tag.

Step 1: Install Ollama

# Linux and macOS, one-command installer
curl -fsSL https://ollama.com/install.sh | sh

On Windows, download the installer from ollama.com/download, or use winget:

winget install Ollama.Ollama

Confirm Ollama is on its latest release, since Qwen3.8 was added recently:

ollama --version

Step 2: Pull and Run qwen3.8

The plain tag pulls the 18GB q4_K_M build, a reasonable starting point for a single 24GB GPU or a Mac with enough unified memory:

ollama run qwen3.8

Expected output on first run:

pulling manifest
pulling 8a3f21c9... 100% ▕████████████████▏  18 GB
pulling tokenizer...   100% ▕████████████████▏ 4.1 MB
success
>>> Send a message (/? for help)

On an Apple Silicon Mac, pull the MLX-optimized tag instead for better performance on the same hardware:

ollama run qwen3.8:27b-mlx

Step 3: Send a Test Prompt

>>> Write a Python function that merges two sorted lists into one, then explain its time complexity.

Since thinking mode is on by default, the terminal shows the model's reasoning first, then the final answer. Expect the first response to take longer than later ones while the model and its context load fully into memory.

Step 4: Verify the Model

ollama list

`qwen3.8:latest` appears in the list at its full download size, 18 GB for the default tag. Unlike a cloud-only model, this confirms the weights are actually on your disk.

Using Vision Input and Controlling Thinking Mode

Qwen3.8 accepts image input alongside text, and its reasoning depth is adjustable per request. Both are useful for anyone building on top of the model rather than only chatting with it interactively.

Send an Image from the Terminal

ollama run qwen3.8 "What is shown in this screenshot? ./error-log.png"

Ollama reads the image file, encodes it, and sends it to the model alongside the text prompt in a single request.

Control Reasoning Depth via the API

curl http://localhost:11434/api/chat -d '{
  "model": "qwen3.8",
  "messages": [
    { "role": "user", "content": "Outline a plan to migrate a Django app from SQLite to Postgres." }
  ],
  "think": true,
  "reasoning_effort": "high",
  "stream": false
}'

Lower `reasoning_effort` values trade reasoning depth for faster, cheaper responses on simpler prompts. `preserve_thinking` (boolean) controls whether the model's reasoning from earlier turns stays in context for later turns in the same conversation, useful for long agentic sessions where earlier reasoning informs later steps, and something to turn off for shorter exchanges where it would only waste context.

Use Qwen3.8 in Your Own Scripts and Agents (API Access)

Beyond the interactive `ollama run` session, Qwen3.8 is reachable through Ollama's REST API and its OpenAI-compatible endpoint, the same interface used by agentic coding tools.

Python Example

from ollama import chat

response = chat(
    model="qwen3.8",
    messages=[{"role": "user", "content": "Refactor this function to use type hints."}],
    think=True,
)
print(response["message"]["content"])

OpenAI-Compatible Endpoint for Existing Agent Tools

Ollama exposes an OpenAI-compatible layer at `http://localhost:11434/v1`, the same endpoint used in the Hermes Agent and OpenClaw setups. Point that configuration at `qwen3.8` instead of a local model name, and the agent runs on Qwen3.8's 256K context window without any other config changes:

model:
  default: qwen3.8
  provider: custom
  base_url: http://localhost:11434/v1
  context_length: 262144

Troubleshooting

Frequently Asked Questions