Qwen3 Coder 30B A3B Instruct: A Local Coding Agent Model

Most coding models fail in agent tools for a boring reason: not bad code, but malformed tool calls. The model writes a sensible edit, wraps it in a format the harness does not parse, and the loop stalls. Qwen3-Coder-30B-A3B-Instruct is interesting less for its size than for how directly it targets that problem, with its own function-call format and parser support built for agentic coding tools.

It is the smaller sibling of Qwen3 Coder 480B A35B. When Qwen announced the 480B model on 22 July 2025 it said more sizes were on the way; this one followed at the end of that month, and it is the size most people can actually run.

What it is

Architecturally it matches the general-purpose 30B A3B models: 30.5B total parameters, 3.3B active per token, 48 layers, 128 experts with 8 routed per token, and grouped-query attention with 32 query heads and 4 key-value heads. The licence is Apache 2.0.

The differences are in training and interface:

• Non-thinking only. It never emits a <think> block. Every output token is code, tool calls or explanation.
• 262,144 tokens of native context, which Qwen says can be extended to about one million with YaRN. That is aimed at repository-scale prompts.
• A recommended output length of 65,536 tokens, four times what Qwen suggests for the general Instruct 2507 model. Coding agents write long files and long diffs.
• Support for agentic coding platforms, with Qwen naming Qwen Code and Cline.

Qwen's model card shows benchmark results for this size only as a vendor-made chart, with no table or methodology alongside it. Treat that as a pointer rather than a headline score, and run your own evaluation rather than dismissing or trusting it on the chart alone.

The tool-call format is the part that breaks

Qwen describes a specially designed function-call format for Qwen3 Coder, and says function calling relies on a new tool parser in both vLLM and SGLang. It also tells users to make sure they use the new tokenizer, because the special tokens and their IDs were updated.

In practice this means three checks before you blame the model:

1. Serving stack version. An older vLLM or SGLang build, or a generic Hermes-style parser, may not parse this model's tool calls correctly. The symptom is tool calls appearing as plain text in the assistant message.
2. Tokenizer. A quantised build repackaged with an old tokenizer can break the special tokens that delimit calls.
3. Hosted provider support. If you rent it, send a request with a tool definition and confirm you get a structured tool_calls field back, not text that looks like one.

Once the plumbing is right, the format is the advantage: a model trained against its own parser tends to produce cleaner calls than a general model coaxed into a foreign schema. Best model for tool calling explains why reliability beats raw intelligence in this role.

Fill-in-the-middle and editor use

Qwen3 Coder supports fill-in-the-middle completion, which is what editor autocomplete needs: the model sees the code before and after the cursor and writes the gap. The prompt uses three special tokens:

<|fim_prefix|>def parse(line):
    <|fim_suffix|>
    return fields<|fim_middle|>

With 3.3B active parameters, per-token latency is low enough for interactive completion on a decent local GPU, which is rarely true of a dense 30B model. That makes it a plausible candidate to serve as both the autocomplete engine and the chat agent in the same editor setup, which is worth testing before you run two models.

The Qwen3 Coder repository lists support for 358 programming languages. Treat that as coverage, not uniform quality: mainstream languages will be far stronger than rare ones.

Coder or the general Instruct 2507?

The obvious alternative is Qwen3 30B A3B Instruct 2507, which has the same architecture, the same 256K window and the same lack of thinking mode.

• Pick Coder for agent loops inside coding tools, FIM completion, and long code generation. The tool format and output budget are built for it.
• Pick Instruct 2507 when coding is one task among many: chat that sometimes writes a script, document work, general tool use. Qwen publishes a full benchmark table for it, including 43.2 on LiveCodeBench v6, so you at least have a reference point.
• Pick a reasoning model for algorithmic problems where planning matters more than typing. Neither of these thinks before answering.

On OpenRouter at the time of writing, the Coder model is listed at $0.07 per million input tokens and $0.28 per million output, slightly below the Instruct 2507 listing. Agentic coding is input-heavy, because every turn resends the repository context, so the input price matters more than it looks.

Running it locally

The weights are roughly 61 GB at two bytes per parameter in BF16. Qwen also publishes an FP8 build using fine-grained quantisation with a block size of 128, which halves that, and community 4-bit builds bring it within reach of a single 24 GB card or a high-memory laptop. Qwen recommends temperature 0.7, top-p 0.8, top-k 20 and a repetition penalty of 1.05.

Remember that 256K tokens of context is a lot of KV cache. Running the full window locally needs far more memory than the weights alone; set the served context to what your tasks actually use.

How to evaluate it on your repository

With only a vendor chart for this size, your own evaluation is the evidence that counts:

1. Take ten closed issues from your repository with known fixes and tests.
2. Run each through your agent harness with this model, starting from the pre-fix commit.
3. Log every malformed tool call separately from wrong code. The first is a configuration problem; the second is the model.
4. Compare pass rate and turns to completion against your current model.

How to benchmark LLMs on your own work has the full harness. If the small Coder passes most of your tasks, the 480B sibling is only worth its cost on the ones it misses.