Qwen3-Coder-480B-A35B-Instruct-Turbo

Qwen3-Coder 480B-A35B Instruct

An agentic coding model that answers directly. No reasoning blocks, by design.

It Does Not Think, and That Is the Point

Stated plainly on the model card:

This model supports only non-thinking mode and does not generate <think></think> blocks in its output.

On most models that would be a limitation. Here it is a design decision, and the workload explains it.

An agentic coding session is hundreds of chained tool calls. Read a file. Run a test. Read the failure. Edit a line. Run it again. Each step is a small, mostly mechanical decision.

A reasoning pass on every one of those steps is latency multiplied by hundreds — and on the majority of them it changes nothing, because the next action was obvious from the tool result.

What you get instead: direct action per step, predictable latency, and an output budget that covers the answer alone.

What you give up: deliberation on the steps that would have benefited. A hard architectural decision inside a long session is answered directly rather than thought through.

The practical shape that follows. Use this model to execute. If a session needs a plan first, make the plan on a reasoning model and hand this one the plan — that division suits both models better than asking either to do both.

A Function-Call Format Built For It

The detail that explains why this model performs differently inside a proper agent harness than behind a generic API call.

Qwen designed a specific function call format for it, and shipped an agent alongside the weights: a command-line coding tool forked from an existing agent and adapted with customised prompts and function calling protocols to match what the model was trained on.

That is an unusual amount of surrounding work for a model release, and it is a signal about where the capability lives — in the model operating inside a harness that speaks its format, not in the weights alone.

Two consequences.

Benchmark results came from that setup. An agentic score produced inside a purpose-built harness will not reproduce in a generic scaffold, and that is true of every agentic benchmark rather than special to this one.

Integration guidance is published for popular agent platforms, including through an OpenAI-compatible base URL — so existing tooling reaches it without a custom client.

A Tool-Calling Bug Worth Knowing About

Documented history, and it explains a class of confusing reports.

Tool calling was broken across every published upload of this model — not one repository, all of them. A community maintainer identified and fixed it, then communicated the fix to the Qwen team.

The fix propagated across the local-inference ecosystem: llama.cpp, Ollama, LM Studio, and the open web interfaces built on them.

Why it matters now. If you encounter an older guide, an older quantisation, or an older local build reporting that tool calling does not work on this model, that is the bug rather than the model.

Through an API this is handled upstream. It matters for self-hosted deployments running anything predating the fix.

Architecture

Thirty-five billion of 480 — roughly seven percent per token. High for a sparse model of this size, and the reason it holds up on tasks where lighter activation would thin out.

Built for Repositories, Not Files

262,144 tokens natively, one million with extrapolation — and Qwen state the optimisation target explicitly: repository-scale understanding, and dynamic data such as pull requests.

That second phrase is the more interesting one. A pull request is not a static document. It is a diff, plus the files it touches, plus the discussion around it, plus the tests it affects. Optimising for that shape is different from optimising for long prose.

What the window makes possible:

Whole-repository reasoning. A change in one module and its consequences three modules away, visible in one context.

Full pull-request review. Diff, surrounding code, and history together rather than a diff in isolation.

Long agent sessions where accumulated tool output does not force compaction after twenty steps.

262,144 is native and a million is extension. The first is trained behaviour; the second widens the window without guaranteeing the far end behaves like the near end. A dedicated 1M variant is published separately with the extension applied.

Specifications

An official FP8 checkpoint is published, alongside community AWQ, GGUF, and 8-bit and 16-bit full-precision builds — plus a separate repository with the 1M context extension pre-applied.

A smaller sibling exists at 30B for the same coding-agent role at a fraction of the footprint.

Capabilities

Using Qwen3-Coder on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=1024,
)

print(response.choices[0].message.content)

Node.js

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    model: "Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo",
    messages: [{ role: "user", content: "Hello world!" }],
    max_tokens: 1024,
  });

  console.log(response.choices[0].message.content);
}

main();

cURL

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

A Coding Agent

The workload the model exists for, with the loop shape that suits a non-thinking model.

import json
import time

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read a file relative to the repository root and return its contents.",
            "parameters": {
                "type": "object",
                "properties": {"path": {"type": "string"}},
                "required": ["path"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "edit_file",
            "description": (
                "Replace an exact string in a file. The old string must appear exactly once, "
                "including whitespace and indentation."
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "old_str": {"type": "string"},
                    "new_str": {"type": "string"},
                },
                "required": ["path", "old_str", "new_str"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "run_tests",
            "description": "Run the test suite and return pass and fail counts with failure output.",
            "parameters": {"type": "object", "properties": {}},
        },
    },
]


def read_file(path: str) -> dict:
    """Replace with your real, sandboxed file access."""
    raise NotImplementedError


def edit_file(path: str, old_str: str, new_str: str) -> dict:
    """Replace with your real, sandboxed editor."""
    raise NotImplementedError


def run_tests() -> dict:
    """Replace with your real, sandboxed test runner."""
    raise NotImplementedError


HANDLERS = {"read_file": read_file, "edit_file": edit_file, "run_tests": run_tests}

session = [
    {
        "role": "system",
        "content": (
            "You are working inside a git repository. Make the smallest change that resolves the "
            "issue, and run the tests after every edit. If a test still fails, read the failure "
            "before editing again. Finish the task rather than leaving a partial fix."
        ),
    },
    {"role": "user", "content": "The DZD invoice test fails on totals ending in .005. Find the cause and fix it."},
]

CEILING = 120
start = time.monotonic()

for step in range(CEILING):
    response = client.chat.completions.create(
        model="Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo",
        messages=session,
        tools=TOOLS,
        max_tokens=16384,
    )

    message = response.choices[0].message
    session.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                # Failures go back as data. The model reads them and adjusts.
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        session.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})

    if step % 20 == 0:
        print(f"step {step:>3} · {(time.monotonic() - start) / 60:>5.1f} min · in {response.usage.prompt_tokens:>8,}")
else:
    print(f"Reached the {CEILING}-step ceiling.")

Three choices worth explaining.

A 120-step ceiling. This model is built for long sessions, and a short leash tests something other than what it was designed for. The ceiling ends a run that will not end itself rather than keeping it brief.

max_tokens at 16,384 with no reasoning sharing it. On a thinking model that budget covers a trace and an answer; here it is all answer, which makes it considerably more generous than it looks.

"Read the failure before editing again." A non-thinking model acts directly on what it sees. Telling it to read the error rather than guess at a fix is how you get the deliberation the model does not do on its own — expressed as an instruction rather than as a reasoning pass.

Plan Elsewhere, Execute Here

The division that suits a non-thinking agent model.

# Stage one — a reasoning model produces the plan.
plan = reasoning_client.chat.completions.create(
    model="<a reasoning model in your catalogue>",
    messages=[
        {
            "role": "system",
            "content": (
                "Produce a numbered implementation plan. Each step should be a single concrete "
                "action against the codebase. Do not write code."
            ),
        },
        {"role": "user", "content": f"{repository_overview}\n\nTask: {task}"},
    ],
    max_tokens=16384,
).choices[0].message.content


# Stage two — this model executes it.
session = [
    {
        "role": "system",
        "content": (
            "Execute the following plan step by step. Run the tests after each step. "
            "If a step fails twice, stop and report which step and why rather than continuing.\n\n"
            f"{plan}"
        ),
    },
    {"role": "user", "content": "Begin."},
]

This uses each model for what it is. Planning is deliberation, which is what a reasoning model does. Execution is a long sequence of direct actions, which is what this model does without paying a per-step latency cost.

The stop-after-two-failures instruction matters on a model that does not reflect. Without it, a step that cannot succeed gets retried indefinitely with small variations, and a 120-step ceiling is consumed by one stubborn edit.

Repository-Scale Review

The other workload the context window was optimised for.

from pathlib import Path

REPO = Path("src")

sources = "\n\n".join(
    f"=== {path.relative_to(REPO.parent)} ===\n{path.read_text(encoding='utf-8')}"
    for path in sorted(REPO.rglob("*.py"))
)

response = client.chat.completions.create(
    model="Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo",
    messages=[
        {
            "role": "system",
            "content": (
                "Review this codebase. Identify every path where a database write can occur outside "
                "a transaction. For each finding, name the file, the function, and the call chain "
                "that reaches it. Report nothing you cannot trace."
            ),
        },
        {"role": "user", "content": sources},
    ],
    max_tokens=32768,
)

print(f"input: {response.usage.prompt_tokens:,} of 262,144")
print(response.choices[0].message.content)

Asking for the call chain rather than the line is what uses a repository-scale window rather than a search. A write outside a transaction is easy to grep for; the path that reaches it from three modules away is the finding that needed the whole repository in one context.

Self-Hosting

Broad support across transformers, SGLang, and vLLM, plus local applications including Ollama, LM Studio, MLX-LM, llama.cpp, and KTransformers.

Official FP8, with community AWQ and GGUF builds, plus full-precision 8-bit and 16-bit versions and a separate repository carrying the 1M YaRN extension pre-applied.

A known FP8 issue, documented by Qwen: the fine-grained FP8 method in transformers has problems with distributed inference. Setting CUDA_LAUNCH_BLOCKING=1 is the documented workaround when multiple devices are involved.

Check your build's tool-calling fix. Anything predating the community fix described above will exhibit broken tool calls regardless of how you configure it.

Fine-tuning and reinforcement learning are supported through the major open training frameworks — relevant given Apache 2.0 and a model specialised for a single domain.

Where It Fits

Agentic coding, which is the design target: long sessions, many tool calls, direct execution.

Repository-scale review and refactoring, with a window optimised for code and pull requests rather than prose.

Editor and CLI integration, with published guidance for popular agent platforms and a purpose-built command-line tool.

Browser-use agents, named alongside coding in the model's stated strengths.

The execution half of a two-model workflow, with planning handled by a reasoning model.

Not for deliberation. Thinking is unsupported; a hard architectural judgment is a different model's job.

Not for vision. Text only.

Not for general assistance. This is a specialist, and the general models in this family are the alternative.

Practical Notes

Give agent loops a generous step ceiling — this model is built to run long.

Size max_tokens for the answer alone; nothing shares it.

Instruct the model to read failures before editing again. That is how you get reflection from a model that does not reflect.

Add a stop-after-repeated-failure rule. Without it, a stuck step consumes the whole ceiling.

Plan on a reasoning model, execute here.

Stay inside 262,144 unless you have measured the extension, or use the dedicated 1M variant.

If self-hosting on multiple devices at FP8, set CUDA_LAUNCH_BLOCKING=1.

Verify your build includes the tool-calling fix before debugging a tool-calling problem.

Limitations

No thinking mode. No reasoning blocks, no effort parameter, no deliberation pass. Deliberate by design, and a real constraint on hard single decisions.

Text only. No image, audio, or video input.

A specialist. Coding and agentic work; general assistance is a different model's job.

262,144 is native; a million is extension. Behaviour at the far end is worth measuring, and a dedicated extended variant exists rather than relying on runtime configuration.

Agentic benchmark results came from a purpose-built harness with custom prompts and a custom function-call protocol. A generic scaffold will produce different numbers.

A documented FP8 distributed-inference issue requires an environment-variable workaround.

Tool calling was broken in every original upload and fixed by the community. Older builds still carry the bug.

Thirty-five billion active parameters is the compute ceiling per token, whatever the 480 billion total suggests.

Direct answers with no visible reasoning. There is less signal about where the model was uncertain, which makes explicit instructions — read the error, stop after two failures, finish the task — carry more weight than they would on a reasoning model.