> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tokios.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Tokios exposes private local models through https://api.tokios.com using an outbound-only connector tunnel.
> Use 'connector' for the local tokios-connector process.
> Use 'deployment' for the public model name in the API model field.
> Use 'upstream model id' for the model served by Ollama, llama.cpp, vLLM, LM Studio, or another local backend.
> API keys use the prefix sk-tok-. Connector tokens use the prefix ct-tok-.

# Run Qwen3-Coder locally and use it from anywhere

> Serve Qwen3-Coder-30B-A3B or the larger 480B tier locally, then reach it from Claude Code, Cline, or any compatible client through Tokios.

> [!NOTE]
>
> Last verified: 2026-10-14

Qwen3-Coder is Qwen's coding-focused open model family for agentic coding, repository-scale context, and tool-using development clients. Start with `qwen3-coder:30b` unless you have a very large unified-memory or multi-GPU system.

> [!NOTE]
>
> For the newer general Qwen line, see [Qwen3.6 on Ollama](https://ollama.com/library/qwen3.6). Its Ollama page lists `27b` and `35b` vision-capable, tool-capable tags with `256K` context. This page stays focused on the legacy `qwen3-coder` family.

## Variants and tags

| Variant | Ollama tag | Architecture | Context | Default download | License | Sources |
| - | - | - | - | - | - | - |
| Practical local coder | [`qwen3-coder:30b`](https://ollama.com/library/qwen3-coder:30b) | MoE, `30.5B` total and `3.3B` activated, `128` experts, `8` activated experts | `256K` native, extendable to `1M` with YaRN on the HF model card | `19GB` | Apache 2.0 | [Ollama Qwen3-Coder](https://ollama.com/library/qwen3-coder), [Qwen/Qwen3-Coder-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct) |
| Large local tier | [`qwen3-coder:480b`](https://ollama.com/library/qwen3-coder:480b) | Large MoE coder model | `256K` | `290GB`; Ollama states local running requires at least `250GB` memory or unified memory | Apache 2.0 on Qwen3-Coder cards | [Ollama Qwen3-Coder](https://ollama.com/library/qwen3-coder), [Qwen3-Coder blog](https://qwenlm.github.io/blog/qwen3-coder/) |
| Hosted Ollama Cloud tier | [`qwen3-coder:480b-cloud`](https://ollama.com/library/qwen3-coder:480b-cloud) | Cloud-served 480B tier | `256K` | Cloud tag, not a local weight download | Apache 2.0 on Qwen3-Coder cards | [Ollama Qwen3-Coder](https://ollama.com/library/qwen3-coder) |

> [!WARNING]
>
> The `480b-cloud` tag is not a local model download. Tokios is for connecting your own local runtime. Use the local `30b` or `480b` tags, or serve Hugging Face weights yourself, when you want a Tokios-backed deployment.

## Quantization and formats

Ollama gives you the simplest `GGUF` path. Hugging Face provides the upstream `safetensors` checkpoint and links out to compatible quantized builds for llama.cpp, Ollama, LM Studio, and similar apps. See [Quantization formats and the hardware they need](https://docs.tokios.com/models/quantization-and-hardware.md) before you choose a quant.

| Format | Use it when | Hardware notes | Sources |
| - | - | - | - |
| Ollama `GGUF` tags | You want one-command local serving | `qwen3-coder:30b` is the practical single-workstation path; `480b` requires far more memory | [Ollama Qwen3-Coder](https://ollama.com/library/qwen3-coder) |
| Hugging Face `safetensors` | You want vLLM, SGLang, Transformers, or custom serving | Use GPU memory planning from your runtime; start with the 30B-A3B checkpoint unless you have multi-GPU capacity | [Qwen/Qwen3-Coder-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct) |
| Other quant repos | You want a specific `Q4`, `Q5`, `Q8`, or full-precision file | Verify the exact repo and filename. Do not assume AWQ, GPTQ, or other formats exist for a tag until the repo lists them. | [Qwen/Qwen3-Coder-30B-A3B-Instruct local apps section](https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct) |

## Hardware fit

The `30b` Ollama tag downloads at `19GB`, so it fits many `24GB` cards with careful context settings. The `480b` tag downloads at `290GB`, and Ollama says it needs at least `250GB` memory or unified memory. Use [Fit a model to your GPU or unified memory](https://docs.tokios.com/guides/model-fit.md) for the sizing method.

| Target | `qwen3-coder:30b` | `qwen3-coder:480b` |
| - | - | - |
| RTX 3090 / 4090, `24GB` | Good starter fit at default Ollama quant; reduce context if you hit OOM | Won't fit |
| RTX 5090, `32GB` | Comfortable for local coding experiments | Won't fit |
| RTX 6000 Ada / A6000, `48GB` | Comfortable, with more context room | Won't fit by itself |
| Apple MLX / unified memory, `36-128GB` | Fits on higher-memory systems; speed depends on bandwidth | Won't fit below the memory class Ollama lists |
| AMD ROCm / Vulkan / Strix Halo | Depends on assignable GPU memory; the `30b` tag is the realistic target | Won't fit unless the system exposes enough usable memory |

## Run it locally first

> [tab] Ollama
>
> Pull the practical local tag:
>
> ```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
> ollama run qwen3-coder:30b
> ```
>
> Check the [Ollama Qwen3-Coder library page](https://ollama.com/library/qwen3-coder) before using a larger tag.

> [tab] LM Studio
>
> Search for **Qwen3-Coder** or a compatible `GGUF` build, choose a quant that fits your memory, and start LM Studio's local server at `http://127.0.0.1:1234/v1`.

> [tab] Unsloth Studio
>
> Search for a Qwen3-Coder `GGUF` build in Unsloth Studio, load the quant that fits, and start its OpenAI-compatible server. See [Use Unsloth Studio from anywhere](https://docs.tokios.com/guides/unsloth-studio-remote-access.md) for the Tokios setup.

> [tab] vLLM
>
> The model card lists a direct vLLM launch:
>
> ```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
> vllm serve "Qwen/Qwen3-Coder-30B-A3B-Instruct"
> ```
>
> Point Tokios at `http://127.0.0.1:8000/v1`. Source: [Qwen/Qwen3-Coder-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct).

> [tab] SGLang
>
> The model card lists a direct SGLang launch:
>
> ```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
> python3 -m sglang.launch_server \
>   --model-path "Qwen/Qwen3-Coder-30B-A3B-Instruct" \
>   --host 127.0.0.1 \
>   --port 30000
> ```
>
> Point Tokios at `http://127.0.0.1:30000/v1`. Source: [Qwen/Qwen3-Coder-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct).

## Capabilities

| Capability | What to expect | Sources |
| - | - | - |
| Coding | Built for agentic coding, browser-use, and foundational coding tasks. | [Qwen/Qwen3-Coder-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct), [Qwen3-Coder blog](https://qwenlm.github.io/blog/qwen3-coder/) |
| Tool calling | The model card says Qwen3-Coder uses a specially designed function-call format and excels in tool calling. Ollama tags the family with `tools`. | [Qwen/Qwen3-Coder-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct), [Ollama Qwen3-Coder](https://ollama.com/library/qwen3-coder) |
| Long context | `256K` native on Ollama and HF; the HF card says the 30B-A3B model can extend to `1M` tokens with YaRN. | [Ollama Qwen3-Coder](https://ollama.com/library/qwen3-coder), [Qwen/Qwen3-Coder-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct) |
| Thinking mode | The 30B-A3B card says the model supports non-thinking mode only and does not generate `<think>` blocks. | [Qwen/Qwen3-Coder-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct) |
| Vision | No. Use [Qwen3-VL](https://ollama.com/library/qwen3-vl) if your coding workflow needs images or screenshots. | [Ollama Qwen3-VL](https://ollama.com/library/qwen3-vl) |

> [!NOTE]
>
> If you hit OOM with Hugging Face weights, Qwen's model card recommends reducing context length, for example to `32,768`.

## Connect it with Tokios

Once Qwen3-Coder runs locally, pair the Tokios connector so Claude Code, Cline, and other clients can call it through `https://api.tokios.com` instead of only `localhost`.

**1. Run Qwen3-Coder locally**

Start with the local `30b` tag:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
ollama run qwen3-coder:30b
```

**2. Pair the Tokios connector**

Sign in at [tokios.com/console](https://tokios.com/console), open **Setup**, and click **Start pairing** to get a one-time claim code shaped `TKS-XXXX-XXXX`.

```bash macOS theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/macos | sh -s -- --code TKS-XXXX-XXXX
```

```powershell Windows theme={"theme":{"light":"github-light","dark":"css-variables"}}
irm https://tokios.com/downloads/install/windows | iex; tokios-install -Code 'TKS-XXXX-XXXX'
```

```bash Linux theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX
```

Approve the device in **Setup** or **Connectors**.

**3. Set the upstream BaseUrl**

For Ollama, point the connector at the `/v1` API:

```json theme={"theme":{"light":"github-light","dark":"css-variables"}}
{
  "Upstream": {
    "BaseUrl": "http://127.0.0.1:11434/v1"
  }
}
```

For LM Studio use `http://127.0.0.1:1234/v1`, for vLLM use `http://127.0.0.1:8000/v1`, and for the SGLang command above use `http://127.0.0.1:30000/v1`.

**4. Register a deployment**

In [Models](https://tokios.com/console/models), register the upstream model and choose a deployment name such as `qwen3-coder-tunnel`.

**5. Create an API key**

In [Keys](https://tokios.com/console/keys), click **Create key**. Copy the `sk-tok-YOUR_KEY` value now because it is shown once.

```bash OpenAI-compatible theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl https://api.tokios.com/v1/chat/completions \
  -H "Authorization: Bearer sk-tok-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3-coder-tunnel",
    "stream": true,
    "messages": [{"role": "user", "content": "Write a TypeScript function that batches async work with a concurrency limit."}]
  }'
```

```bash Claude Code theme={"theme":{"light":"github-light","dark":"css-variables"}}
export ANTHROPIC_BASE_URL=https://api.tokios.com
export ANTHROPIC_API_KEY=sk-tok-YOUR_KEY
claude --model qwen3-coder-tunnel
```

> [!TIP]
>
> The `model` field is always your registered deployment name, not `qwen3-coder:30b` or the Hugging Face model id.

## Next steps

> [card] [Quickstart](https://docs.tokios.com/quickstart.md)
>
> Pair a connector and register your first deployment end to end.

> [card] [Use Claude Code](https://docs.tokios.com/guides/claude-code.md)
>
> Point Claude Code at your Tokios deployment.

> [card] [Fit a model to your GPU](https://docs.tokios.com/guides/model-fit.md)
>
> Estimate whether the `30b` or `480b` tier fits your machine.

> [card] [Quantization and hardware](https://docs.tokios.com/models/quantization-and-hardware.md)
>
> Pick a format before you download a large quant.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.