Skip to main content

Qwen3-30B-A3B: Which Version Should You Run Locally?

Use Instruct-2507 for everyday instructions, Thinking-2507 for reasoning-focused work, Coder for code, or the original when you need switchable thinking. An explicit model tag and a short context window make the first local check easier to interpret.

LaoZhang AI TeamPublishedUpdated 11 min read
On this page
Qwen3-30B-A3B model choices for a local setup

For everyday local chat, summaries, and structured answers, start with Qwen3-30B-A3B-Instruct-2507. For coding, start with Qwen3-Coder-30B-A3B-Instruct. Choose Thinking-2507 when extended reasoning is part of the task, and choose the original Qwen3-30B-A3B when you want one checkpoint that can switch between thinking and non-thinking modes.

The important distinction is the full model name. These checkpoints share the 30B-A3B label, but their thinking behavior and context limits differ. A short Ollama tag also needs inspection: ollama run qwen3 selects the family's default model, which was 8B, not 30B, when checked on October 7, 2026. Use an explicit tag for a 30B setup. (Ollama Qwen3 library)

Which Branch Should You Run?

Your main taskFirst checkpoint to considerWhat changes the choice
Summaries, extraction, drafting, ordinary chatQwen/Qwen3-30B-A3B-Instruct-2507Fixed non-thinking mode; a useful starting point when you want the answer without a separate thinking trace
Complex reasoning, math, or planningQwen/Qwen3-30B-A3B-Thinking-2507Fixed thinking mode; allow room for deliberation and judge the final answer against known constraints
Code changes, repository questions, tool-assisted programmingQwen/Qwen3-Coder-30B-A3B-InstructCoding-oriented, non-thinking checkpoint; tool integration must understand its call format
A mix of quick answers and optional thinking in one modelQwen/Qwen3-30B-A3BOriginal hybrid checkpoint; keep its smaller native context limit in mind

These choices follow the checkpoints' documented purposes and mode controls, rather than a claim that one wins every task. The Instruct card still covers reasoning and coding capabilities: “non-thinking” does not mean it cannot solve a reasoning problem. The Thinking card targets highly complex reasoning, while the Coder card emphasizes agentic coding and a specialized function-call format.

For example, if most of your work is turning notes into a short report, Instruct is the straightforward first choice. If you occasionally need to reason through a difficult plan and want to change modes without loading a different checkpoint, the original hybrid model remains useful. If the job is to repair code and pass tests, Coder is the more relevant first candidate. None of those recommendations establishes a measured speed or accuracy advantage on your machine.

Original thinking controls do not carry over to every version

In the original Hugging Face model, enable_thinking belongs to the tokenizer's chat-template call. Setting it to False disables thinking; with it enabled, /think and /no_think in the conversation provide soft mode switches. A soft instruction cannot turn thinking back on after that hard disable.

The 2507 checkpoints have fixed modes. Instruct-2507 is non-thinking only; Thinking-2507 is thinking only. You cannot turn Instruct into Thinking-2507 by adding /think, or turn Thinking-2507 into Instruct by adding /no_think. Thinking-2507's template already supplies the opening thinking tag, so generated text containing a closing tag without a new opening tag can be normal. (Instruct mode, Thinking mode)

Ollama uses its own think request field. It is not a replacement spelling for Hugging Face's enable_thinking, and the installed model must support the requested mode. Check the model before treating a toggle as proof of which upstream checkpoint you have.

What A3B Means—and How Much Memory You Need

Qwen's model cards list 30.5 billion total parameters and 3.3 billion activated parameters for these checkpoints. The original uses 128 experts, with eight activated per token. A3B describes the smaller active portion of this mixture-of-experts model; it does not shrink the stored weights to the size of a 3B model. (Original model specifications)

As a lower-bound calculation, 30.5 billion parameters at exactly four bits each would occupy:

30.5 billion × 4 bits ÷ 8 = 15.25 GB, or about 14.20 GiB

That ideal payload excludes quantization scales, components kept at higher precision, file overhead, and runtime memory. The named Ollama Q4_K_M Instruct and Coder artifacts were listed at approximately 19 GB on October 7. Their download size is not a peak RAM or VRAM measurement. (Instruct artifact, Coder artifact)

For context memory, consider the exact Coder configuration: 48 layers, four KV heads, and a head dimension of 128. If the runtime stores keys and values in 16-bit precision, one sequence has this ideal KV-cache payload:

2 (key and value) × 48 layers × 4 KV heads × 128 × 2 bytes
= 98,304 bytes per stored token
Stored tokens in one sequenceIdeal F16 KV payload
8,1920.75 GiB
32,7683 GiB
65,5366 GiB
262,14424 GiB

This is an arithmetic illustration based on the Coder configuration, not a measured allocation. Cache quantization, padding, activations, runtime overhead, and parallel requests change the result. In particular, four active request slots can require substantially more cache than the one sequence shown here.

The practical decision is to choose the quantized artifact and a realistic context length together. A 16 GB GPU cannot hold a roughly 19 GB artifact entirely in VRAM even before cache and other overhead; CPU offload may provide a route, but it changes the performance question. A 24 GB GPU also should not be assumed to fit the same weights plus a full 256K F16 cache. With unified memory, budget for the operating system and other applications as well. Start with a short window, inspect placement, and expand only as your actual task needs it.

Run Instruct or Coder with an Explicit Ollama Tag

The following is a documented local starting route for a machine with Ollama already installed and its local service available. Downloading these artifacts takes storage and network capacity, and the machine still needs enough usable memory. We have not downloaded or run the models for this guide; the commands illustrate the setup and checks.

For Instruct-2507, the explicit published Q4_K_M tag is:

bash
ollama pull qwen3:30b-a3b-instruct-2507-q4_K_M
ollama show qwen3:30b-a3b-instruct-2507-q4_K_M
ollama show --modelfile qwen3:30b-a3b-instruct-2507-q4_K_M

For the coding checkpoint, use:

bash
ollama pull qwen3-coder:30b
ollama show qwen3-coder:30b
ollama show --modelfile qwen3-coder:30b

The Instruct tag page and Coder tag page identify the published packages. show lets you inspect the local model's details; show --modelfile exposes its template and parameters. Record the model identifier, quantization, context metadata, and template before comparing two setups. A tag can change over time, so a descriptive name alone is insufficient for strict reproduction.

The shorter qwen3:30b-a3b and qwen3:30b tags both pointed to digest ad815644918f in the October 7 snapshot; the explicit Instruct tag pointed to 19e422b02313. That difference is a reason to inspect, not evidence that one package is better. The short tags' metadata advertised 262,144 context tokens, which also does not make them proof of the original upstream model's 32,768-token native limit. (30b-a3b tag, 30b tag)

Send a short request with a deliberate context budget

After obtaining Instruct, this request sets an 8,192-token window and asks a question with an independently checkable answer:

bash
curl http://localhost:11434/api/chat -d '{
  "model": "qwen3:30b-a3b-instruct-2507-q4_K_M",
  "stream": false,
  "messages": [{
    "role": "user",
    "content": "Write a two-sentence inventory note. The Kite kit has 42 units on hand, including 11 reserved and 3 quarantined units. Another 12 units are inbound but have not arrived. Available means on hand minus reserved minus quarantined; inbound stock is excluded. State the available quantity and correct this draft claim: We can ship 52 kits today."
  }],
  "options": {"num_ctx": 8192}
}'

stream: false requests a single response. The answer should appear in message.content; the required quantity is 28 available units, from 42 − 11 − 3. The 12 inbound units must not be counted as available. These are the example's acceptance criteria, not output observed from a model. Check both the arithmetic and whether the reply follows the two-sentence instruction. This small task is useful for confirming the request works before adding a large document; it cannot establish general model quality.

For a coding check, use qwen3-coder:30b as the model and ask it to implement the same availability rule as a function, with tests for reserved stock, quarantined stock, and inbound stock. Inspect and run that proposed code separately. A model returning a tool call or code block has not executed it; execution depends on your application and permissions. The Coder card's function-call format is relevant when you later integrate tools. (Coder model card)

While the model is still resident, run this in another terminal:

bash
ollama ps

Confirm the expected model is present, check PROCESSOR for GPU/CPU placement, and check CONTEXT for the allocated window. For this request, look for 8,192 rather than assuming the advertised 262,144 was allocated. If the model has unloaded, repeat the request and inspect it while resident. (Ollama context documentation)

Check thinking support before changing think

The current Ollama thinking documentation exposes supported values and the default in /api/show:

bash
curl http://localhost:11434/api/show -d '{
  "model": "qwen3:30b-a3b-instruct-2507-q4_K_M"
}'

Look for the documented thinking.values and thinking.default fields where available. For a model that supports disabling thinking, the /api/chat request can include top-level "think": false; a supported thinking request can use "think": true. Omitted metadata is not proof that a model has no internal thinking. When thinking is returned separately, Ollama puts it in message.thinking, with the final answer in message.content. (Ollama thinking controls)

Do not use --hidethinking as a substitute for disabling generation: it hides display. For the original hybrid or Thinking-2507, choose a package whose upstream model and template you can verify against the exact Qwen ID. The Instruct and Coder commands above do not install Thinking-2507, and guessing a similarly named tag is not a reliable deployment method.

Local runtime choices and context settings for Qwen3-30B-A3B

Hardware And Context Caveats: 32K, 256K, and 1M Are Different Claims

Exact upstream checkpointNative contextLonger-context condition
Original Qwen3-30B-A3B32,768131,072 with YaRN
Instruct-2507262,144A separate specialized 1M recipe
Thinking-2507262,144A separate specialized 1M recipe
Coder-30B-A3B-Instruct262,144Advertised extension to 1M with YaRN

Native capacity, runtime model metadata, allocated context, and usable input budget are separate quantities. Even an allocated 8,192-token window must accommodate the prompt template, conversation history, supplied documents, and generated output. Reserving 2,048 tokens for output leaves at most 6,144 for everything before that output, before accounting for those other inputs. A 256K label does not mean you can submit 256K input tokens and then generate freely beyond them.

Ollama's documentation also currently disagrees about the default. Its context-length source, checked October 7, describes VRAM-based defaults of 4K below 24 GiB, 32K from 24 to below 48 GiB, and 256K at 48 GiB or more. The FAQ still states a 4,096-token default. Set options.num_ctx explicitly for a reproducible request and use ollama ps to see the actual allocation on your installed version.

The 2507 cards' 1M route uses Dual Chunk Attention, MInference, a replacement configuration, and specialized serving instructions. Those cards describe approximately 240 GB of total GPU memory for that recipe, including weights, KV cache, and peak activations. This is neither a requirement for the short local example above nor a promise that a normal 4-bit Ollama package can use 1M context. Treat that recipe as a separate deployment project, with engine-version support to verify. (Instruct ultra-long context, Thinking ultra-long context)

Decide Whether to Replace Your Current Local Model

After the short request succeeds, use work you can judge: a report with known source facts, a planning problem with explicit constraints, or a code change with existing tests. Keep the input and required result consistent while comparing checkpoints. Record the exact artifact, template, quantization, allocated context, hardware placement, and thinking setting so that an apparent model difference is not just a setup difference.

The inventory example gives you a concrete first check. An answer of 40 has incorrectly included inbound stock; 52 repeats the faulty claim; 28 is correct only if the note also preserves the availability rule. For the coding version, verify that changing inbound stock alone does not change availability. These checks distinguish task completion from an answer that merely sounds convincing.

Comparing local Qwen3-30B-A3B setups on the same task and requirements

For your real workload, compare accepted answers or passing changes, time to review, retries, and memory pressure. Thinking-2507 may be worth the extra deliberation on a difficult task, while Instruct may be sufficient for routine work. Coder's specialization is a reason to try it for code, not permission to accept a patch without tests. The original's switchable mode can be more convenient when you need both behaviors in one checkpoint.

What about Qwen3.6 or Qwen3.8?

They are separate comparison candidates. Qwen3.6-35B-A3B is a 35B MoE with a vision encoder; Qwen3.8-27B is a dense vision-language model with hybrid attention and a 262,144-token native window. They are not updated aliases for these 30B checkpoints, and a newer model name alone does not establish a better result or a smaller memory footprint for your task.

If your decision has shifted to the 27B model's hardware requirements, the Qwen3.8-27B VRAM guide covers its distinct weight, cache, RTX 5090, and dual-GPU considerations. Use the exact model's requirements rather than transferring this Coder KV calculation to a different architecture.

FAQ

Is Qwen3-30B-A3B still worth running?

Yes, when its mode and task fit your needs. The original is useful for switchable thinking in one checkpoint, Instruct-2507 for non-thinking instruction work, Thinking-2507 for reasoning-focused work, and Coder for coding. These are different choices; a later Qwen family does not automatically make all four unsuitable. (Original card, 2507 Instruct card, Coder card)

Does A3B mean I only need memory for three billion parameters?

No. The model has 30.5 billion total parameters and activates 3.3 billion per token. You still need to account for the full stored weights, cache, and runtime overhead. The explicit Ollama Q4_K_M Instruct package was about 19 GB in the October 7 snapshot, before runtime allocation. (Model specifications, Ollama package)

Should I use Instruct-2507 or Thinking-2507?

Start with Instruct for ordinary instructions and short final answers. Try Thinking for problems that justify extended deliberation and assess it against known answers or constraints. They are fixed-mode checkpoints, so /think and /no_think cannot switch one into the other. (Instruct, Thinking)

Is Qwen3-Coder-30B-A3B good for coding?

Its documented focus makes it a relevant first candidate for code and tool-assisted programming. It is a separate non-thinking checkpoint with a specialized function-call format, not a guarantee that it will fix your repository correctly. Evaluate generated changes with your tests and confirm your tool integration supports the format. (Coder model card)

Why isn't my Ollama model using the advertised context window?

The model's advertised capacity and the runtime's allocated window differ. Set options.num_ctx for the request, then inspect CONTEXT in ollama ps while the model is resident. A larger allocation needs more memory, and input and output still share that window. (Ollama context documentation)

When was Qwen3-30B-A3B released?

The original Qwen3 launch was April 29, 2025. The 2507 suffix identifies the July 2025 updates, not a 2026 release. The Qwen3-Coder family announcement should not be used to assign an exact release date to every size: its July 22 introduction concerned the 480B model. (Original launch, 2507 model card, Coder announcement)

Is Qwen3.8-27B the newer version of Qwen3-30B-A3B?

It is a separate dense vision-language model, not a renamed 30B-A3B checkpoint. Compare it when its capabilities suit your work, using its own memory requirements and task results. Its architecture and context behavior should not be inferred from the older MoE name. (Qwen3.8-27B model card)

Sources17

External pages this guide links to, in the order they appear. Last updated Oct 8, 2026.

  1. 1.Ollama Qwen3 libraryollama.com/library/qwen3
  2. 2.Instruct cardhuggingface.co/Qwen/Qwen3-30B-A3B-Instruct-2507
  3. 3.Thinking cardhuggingface.co/Qwen/Qwen3-30B-A3B-Thinking-2507
  4. 4.Coder cardhuggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct
  5. 5.original Hugging Face modelhuggingface.co/Qwen/Qwen3-30B-A3B
  6. 6.Instruct artifactollama.com/library/qwen3:30b-a3b-instruct-2507-q4_K_M
  7. 7.Coder artifactollama.com/library/qwen3-coder:30b
  8. 8.Coder configurationhuggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct/blob/main/config.json
  9. 9.30b-a3b tagollama.com/library/qwen3:30b-a3b
  10. 10.30b tagollama.com/library/qwen3:30b
  11. 11.Ollama context documentationgithub.com/ollama/ollama/blob/main/docs/context-length.mdx
  12. 12.Ollama thinking controlsdocs.ollama.com/capabilities/thinking
  13. 13.FAQdocs.ollama.com/faq
  14. 14.Qwen3.6-35B-A3Bhuggingface.co/Qwen/Qwen3.6-35B-A3B
  15. 15.Qwen3.8-27Bhuggingface.co/Qwen/Qwen3.8-27B
  16. 16.Original launchqwenlm.github.io/blog/qwen3
  17. 17.Coder announcementqwenlm.github.io/blog/qwen3-coder
Local deployment decision board comparing Qwen3.8 Flash-Next with Qwen3.8-27B
Model Comparisons

Qwen3.8 Flash-Next vs 27B: Which Model Should You Run Locally?

Start with Qwen3.8-27B when memory, a simpler serving setup, and Apache-2.0 matter most. Test Flash-Next if you can host its much larger weights and want to evaluate its reported advantages on coding and agent tasks.

8 min
Connect OpenClaw to local or hosted inference and verify replies and tool use
Developer Tools & Agents

OpenClaw LLM Setup: Connect Local Models, Cloud Providers, and Fallbacks

Run OpenClaw onboarding on the Gateway host, connect the provider or local server, then select an exact model from its catalog. Verify both a short reply and a harmless tool task. Configured defaults can use fallbacks; a manually pinned chat model remains strict.

14 min