Qwen3-Coder-Next

Qwen3-Coder-Next

Works as a coding agent model with 80B total and 3B active parameters and a 256K context. For developers who run agents in CLI and IDE tools and want to host the model themselves.

Made by Qwen on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Qwen3-Coder-Next is an open-weight language model from the Qwen team, made for coding agents and local development. It has 80B parameters in total, with only 3B active for each token. The card says it reaches results comparable to models with 10 to 20 times more active parameters.

Who it suits: Developers and teams who want to host their own coding agent model and plug it into the tools they already use.

Industry | Who uses it | How they use it | Example
Software | Developers | Run a coding agent against a local model | Let an agent edit files in a project
Dev tooling | Platform teams | Serve the model behind an OpenAI-compatible API | Point an IDE assistant at the endpoint
Research | AI engineers | Study a mixture-of-experts coding model | Compare it with other coding models

If you have no multi-GPU or large-memory machine, you can skip hosting it yourself.

Where to use it:

• CLI and IDE tools the card names, including Claude Code, Qwen Code, Qoder, Kilo, Trae and Cline
• Ollama and LMStudio, which the card says also support the Qwen3 line
• MLX-LM, llama.cpp and KTransformers, listed the same way
• SGLang or vLLM, which can serve it behind an OpenAI-compatible API

Use case | Who | What they get back
Coding agents | Developers | An agent that plans, calls tools and recovers from failures
Local development | Developers | Code help from a model on your own machine
API hosting | Platform teams | An OpenAI-compatible endpoint

How to set it up:

• Python with pip
• A recent transformers release
• Large memory, with about 159 GB of BF16 weights, or about 39.8 GB at 4-bit (an estimate)
• sglang 0.5.8 or newer, only if you want to serve it

1. Install the Hugging Face hub tool.
2. Download the model files.
3. Run the Python snippet below, or install SGLang and launch a server.

pip install -U huggingface_hub
hf download Qwen/Qwen3-Coder-Next

For serving, the card gives these two SGLang commands.

pip install 'sglang[all]>=v0.5.8'
python -m sglang.launch_server --model Qwen/Qwen3-Coder-Next --port 30000 --tp-size 2 --tool-call-parser qwen3_coder

How to use it: Send a user message through the chat template, generate, and decode the new tokens. If you run out of memory, shorten the context, for example to 32,768.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Qwen/Qwen3-Coder-Next"

# load the tokenizer and the model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
  model_name,
  torch_dtype="auto",
  device_map="auto"
)

# prepare the model input
prompt = "Write a quick sort algorithm."
messages = [
  {"role": "user", "content": prompt}
]
text = tokenizer.apply_chat_template(
  messages,
  tokenize=False,
  add_generation_prompt=True,
)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

# conduct text completion
generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=65536
)
output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()

content = tokenizer.decode(output_ids, skip_special_tokens=True)

print("content:", content)

Tool | What it does
sglang.launch_server | Starts an OpenAI-compatible server for the model
--tool-call-parser qwen3_coder | Parses the model's tool calls
--port 30000 | Sets the port the server listens on

Example: You run the snippet unchanged, which asks the model to write a quick sort algorithm. The script prints the model's answer after the label content.

For newcomers and experts: If you are new, know that this model is built for agents, so the hosted tools in the list above are an easier start than hosting it. The weights need a lot of memory.

For experts, the model alternates Gated DeltaNet and Gated Attention layers, each followed by a mixture of experts. The card lists 48 layers, 512 experts with 10 activated and 1 shared, and a native 262,144-token context.

An agent tool sends a coding task
The server applies the chat template
A few of 512 experts handle each token
The reply or tool call goes back

Good to know: The model supports only non-thinking mode and writes no think blocks.

Title: Parameters from the card
Total parameters: 80 billion
Activated parameters: 3 billion

• License: Apache 2.0, as the Hugging Face record lists it.
• Cost to run: no API key or account is named. You need hardware for the weights.
• Data it reaches: downloading reaches Hugging Face. The model itself does not reach out, though agent tools around it may touch your files.
• Not for: thinking mode, which the card says is not supported.

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 79.7B
• Weights: about 159 GB in BF16; about 39.8 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 423,853
• Likes: 1,741
• License: apache-2.0
• Quantized versions: 120
• Fine-tunes: 43
• Tags: transformers, safetensors, qwen3_next, text-generation, conversational

Links

• Model: https://huggingface.co/Qwen/Qwen3-Coder-Next
• Files: https://huggingface.co/Qwen/Qwen3-Coder-Next/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Qwen/Qwen3-Coder-Next

Then follow the usage in its model card. Nothing in this kit runs by itself.