> ## 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-.

# GLM-5.3: weights, hardware, and local deployment

> GLM-5.3 weights are live on Hugging Face (zai-org/GLM-5.3). 753B total parameters, ~40B active MoE, 1M token context. Covers hardware sizing, licensing, and local serving.

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

**GLM-5.3 weights are released.** Z.ai [announced GLM-5.3 on 2026-08-14](https://z.ai/blog/glm-5.3) and the weights went live on Hugging Face at [zai-org/GLM-5.3](https://huggingface.co/zai-org/GLM-5.3) on approximately 2026-08-27. The model is also available through the Z.ai API, the GLM Coding Plan, and ZCode.

> [!NOTE]
>
> GLM-5.3 uses the **same base model as GLM-5.2** — every gain comes from post-training — so the parameter count, memory profile, and serving path carry over unchanged.

## GLM-5.3 release date and status

| Item | Status |
| - | - |
| Announcement | [Z.ai blog](https://z.ai/blog/glm-5.3), 2026-08-14 |
| API access | Live — Z.ai API, GLM Coding Plan, ZCode |
| Weights and model card | Released \~2026-08-27 on Hugging Face at [zai-org/GLM-5.3](https://huggingface.co/zai-org/GLM-5.3) |
| Base model | Unchanged from GLM-5.2 |
| Parameter count | `753B` total, \~`40B` active, MoE architecture |
| Context length | 1M tokens input, \~128K output |
| License | Custom "glm-5.3" license — companies with >\$10B revenue over 12 months need Z.ai security review |
| Ollama tag | Not published |

> [!WARNING]
>
> **GLM-5.3 uses a custom license, not MIT.** The license restricts commercial use for large companies. If your organization exceeds \$10B in annual revenue over 12 months, you must complete a Z.ai security review before production deployment. GLM-4 through GLM-5.2 shipped under MIT; GLM-5.3 does not.

### GLM-5.3-Flash: a separate, MIT-licensed option

Z.ai also released **GLM-5.3-Flash** (`320B` parameters), which remains **MIT-licensed** with no commercial restrictions. This is a separate, smaller model — not a quantization of GLM-5.3. Community GGUF uploads are available at AtomicChat/GLM-5.3-Flash-GGUF.

If you need a permissively licensed GLM model at this tier, GLM-5.3-Flash is the option.

If you want a smaller GLM model running today, use the [GLM family page](https://docs.tokios.com/models/glm.md). `GLM-4` `9B` is a one-command Ollama pull on a single consumer GPU, and `GLM-4.5-Air` fits a large unified-memory machine.

## What actually changed from GLM-5.2

Z.ai describes GLM-5.3 as a post-training release: the pretrained base is identical, and the improvements come from scaled reinforcement learning on long-horizon task environments. The reported gains are large, particularly on agentic coding.

| Benchmark | GLM-5.2 | GLM-5.3 |
| - | - | - |
| Terminal Bench 3.0 | 4.6 | 28.3 |
| Terminal Bench 2.1 | 81.0 | 88.2 |
| DeepSWE v1.1 | 46.2 | 66.9 |
| FrontierSWE | 67.5 | 78.1 |
| SWE-Marathon v1.1 | 19.4 | 42.5 |
| Toolathlon Verified | 59.9 | 73.0 |
| Agents' Last Exam (ALE-CLI) | 23.8 | 28.5 |
| HLE with tools | 54.7 | 62.5 |

Z.ai also reports better token efficiency, not just higher scores: on its in-house Z.ai Code Bench at max effort, GLM-5.3 reaches 34.5% using roughly 75K output tokens per task, against 23.4% at 96K for GLM-5.2. All figures above are the vendor's own, measured with their harness settings — treat them as a direction of travel until independent evaluations land.

The release also reports a sharp jump in vulnerability-discovery capability, which Z.ai says grew faster than expected as post-training scaled. Working with security teams, the model surfaced 2,436 findings across 269 open-source projects, 1,097 of them medium-to-high severity, tracked in a public disclosure ledger. That matters here only as a capability signal; it does not change how you serve the model.

## The API change that breaks upgrades

> [!WARNING]
>
> **Thinking can no longer be disabled.** GLM-5.2 accepted `thinking.type: "disabled"`; GLM-5.3 rejects it, and the request fails. If your application runs GLM with thinking off, you must switch to `thinking.type: "enabled"` with `reasoning_effort: "low"` *before* changing the model id.

GLM-5.3 exposes three reasoning levels through `reasoning_effort` — `low`, `high`, and `max` — defaulting to `max`, which Z.ai recommends for coding work:

```json theme={"theme":{"light":"github-light","dark":"css-variables"}}
{
  "model": "glm-5.3",
  "thinking": { "type": "enabled" },
  "reasoning_effort": "max"
}
```

This is worth planning for if you serve GLM locally, because the same parameter contract carries into the open-weight release and its runtime flags.

## GLM-5.3 hardware requirements

Weight memory follows stored parameter count and quantization. GLM-5.3 stores **753B parameters** in a mixture-of-experts layout:

| Precision | Weight floor at 753B |
| - | - |
| Unsloth 2-bit | \~245 GB |
| 4-bit | \~377 GB |
| FP8 | \~755 GB |
| BF16 | \~1.5 TB |

Those are weights only. Read them as the floor beneath which nothing runs, not as a requirement — KV cache, runtime buffers, and system reservation all come on top.

> [!TIP]
>
> **245 GB at 2-bit fits a 256 GB Mac.** An Unsloth 2-bit quantization of GLM-5.3 fits within the unified memory of a 256 GB Apple Silicon machine, leaving headroom for the OS and runtime. This is the first practical single-machine path to self-hosting GLM-5.3.

> [!WARNING]
>
> In a mixture-of-experts model every expert weight stays resident even though only a fraction activates per token. Memory scales with **total** parameters, not active ones, so do not size a machine from an active-parameter count. See [how inference works](https://docs.tokios.com/concepts/how-inference-works.md).

At full precision (BF16), you need an \~8-GPU datacenter server. FP8 cuts that roughly in half but still requires multi-GPU infrastructure.

### Fit by device

Every verdict assumes the tightest quantization that fits the target.

| Target | Verdict |
| - | - |
| RTX 3090 / 4090 (24 GB) | Nowhere close |
| RTX 5090 (32 GB, Blackwell) | Nowhere close |
| RTX 6000 Ada / A6000 (48 GB) | Nowhere close |
| Apple Silicon (128 GB unified) | Not practical at 4-bit; 2-bit (\~245 GB) still exceeds capacity |
| Apple Silicon (256 GB unified) | Fits Unsloth 2-bit (\~245 GB) with headroom |
| AMD Strix Halo (up to 128 GB) | Not practical |
| One DGX Spark (128 GB unified) | Won't fit — roughly a third of the 4-bit weight floor |
| Four DGX Sparks (512 GB pooled) | First configuration with real headroom at 4-bit |
| Multi-GPU data-center server | The intended tier for FP8 and BF16 |
| Hosted endpoint | What most people will actually use |

### Can a DGX Spark run GLM-5.3?

Not one, and probably not two. A [DGX Spark](https://docs.tokios.com/use-cases/dgx-spark.md) holds 128 GB of unified memory against a \~377 GB weight floor at 4 bits. Three Sparks clear that floor on paper at 384 GB, but leave about 7 GB total for the operating system, runtime buffers, and KV cache across the whole cluster — unusable in practice. Four Sparks at 512 GB is the first configuration with genuine headroom.

An Unsloth 2-bit build (\~245 GB) does not fit a single Spark either — you would need two at 256 GB pooled, and even then headroom is tight.

See [DGX Spark model compatibility](https://docs.tokios.com/guides/dgx-spark-model-compatibility.md#glm-52-feasibility) for the sizing method.

### Can a 24 GB GPU run GLM-5.3?

No, and offloading will not rescue it. A 24 GB card is short of even the 245 GB 2-bit weight floor by an order of magnitude. Streaming weights from system RAM or disk at that ratio collapses throughput to the point of uselessness — see [memory and offloading](https://docs.tokios.com/concepts/memory-and-offloading.md) for why.

If you have a single consumer GPU and want a GLM model, run `GLM-4` `9B` at 5.5 GB:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
ollama run glm4
```

Then reach it from anywhere with Tokios. For a fuller picture of what your hardware can hold, use [what size model fits your GPU?](https://docs.tokios.com/guides/model-fit.md).

### Context is a separate budget

The figures above cover weights only. GLM-5.3 is natively 1M tokens, and a context that long can cost more memory than a mid-size model's entire weight set. Budget for it separately — see [KV cache and context](https://docs.tokios.com/concepts/kv-cache-and-context.md).

## GLM-5.3 download and Ollama

GLM-5.3 weights are available on Hugging Face at [zai-org/GLM-5.3](https://huggingface.co/zai-org/GLM-5.3). For GLM-5.3-Flash, community GGUF uploads are at AtomicChat/GLM-5.3-Flash-GGUF.

There is no official Ollama tag yet. A guessed command such as `ollama run glm-5.3` will not work. Note the pattern from GLM-5.2: it is listed on Ollama only as `glm-5.2:cloud`, which routes to Z.ai's hosted infrastructure rather than downloading weights. At this size class, expect a cloud tag rather than a local pull.

## Run it — beginner to advanced

> [tab] vLLM (GPU serving)
>
> ```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
> vllm serve "zai-org/GLM-5.3"
> ```
>
> GLM-5.2 requires `--reasoning-parser glm45` and `--tool-call-parser glm45` for tool calls and thinking output to separate correctly. GLM-5.3 uses the same base model, so expect equivalent flags — confirm against the model card before you standardize. See [vLLM remote access](https://docs.tokios.com/guides/vllm-remote-access.md).

> [tab] SGLang
>
> ```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
> python -m sglang.launch_server --model-path "zai-org/GLM-5.3"
> ```
>
> SGLang serves the same OpenAI-compatible endpoint. As with vLLM, expect to need reasoning-parser and tool-call-parser flags equivalent to the `glm45` flags GLM-5.2 uses. Check the SGLang docs and the model card for current syntax.

> [tab] Ollama
>
> No official Ollama tag exists yet. A guessed command such as `ollama run glm-5.3` will not work. GLM-5.2 appears on Ollama only as `glm-5.2:cloud`, which routes to Z.ai's hosted infrastructure rather than downloading weights. At this size class, expect a cloud tag rather than a local pull when it ships.
>
> For a GLM model you can pull and run locally today, see the [GLM family page](https://docs.tokios.com/models/glm.md).

## Connect it with Tokios

An always-on local deployment is one you want to reach when you are not at the machine running it. Tokios sits after your serving runtime: it does not download the model or replace vLLM or SGLang.

**1. Keep your serving runtime running**

Start GLM-5.3 in vLLM or SGLang and leave it bound to loopback.

**2. Pair the Tokios connector**

Sign in at [tokios.com/console](https://tokios.com/console), open the **Setup** tab, and click **Start pairing** to get a one-time claim code (`TKS-XXXX-XXXX`). Run the installer on the machine that runs the model:

```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 macOS theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/macos | sh -s -- --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
```

Then **approve** the device on the **Setup** or **Connectors** tab.

**3. Register a deployment**

In the [Models](https://tokios.com/console/models) tab, register the upstream model id (for example `zai-org/GLM-5.3`) under a public deployment name like `glm-5.3`. Clients send the deployment name in the `model` field, never the local id — so swapping GLM-5.2 for GLM-5.3 later changes nothing on the client side.

**4. Create an API key**

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

### Call it from anywhere

```bash curl (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": "glm-5.3",
    "stream": true,
    "thinking": { "type": "enabled" },
    "reasoning_effort": "max",
    "messages": [
      {"role": "user", "content": "Audit this repository and propose a phased refactor."}
    ]
  }'
```

```bash Claude Code (Anthropic-compatible) 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 glm-5.3
```

## GLM 5.3 Prime

**GLM 5.3 Prime** is a speed-optimized variant of the same 753B base model. It delivers approximately 1.5-2x faster output than standard GLM-5.3 with no change in model quality.

| Property | Value |
| - | - |
| Base parameters | 753B (same as GLM-5.3) |
| Speed | \~1.5-2x faster output |
| Thinking mode | Always on — `low`, `high`, or `max` |
| API model id | `z-ai/glm-5.3-prime` |

Prime is not a separate model — it is the same weights with inference optimizations applied. Use it when you need faster throughput without changing your prompts or reasoning configuration.

## Capabilities

* **Controllable reasoning.** Three effort levels — `low`, `high`, `max` — via `reasoning_effort`, defaulting to `max`. Thinking can no longer be disabled; use `low` when you need faster responses.
* **Tool calling.** GLM-5.3 supports structured tool calls. Serving runtimes need the correct `--tool-call-parser` flag (equivalent to GLM-5.2's `glm45` flag) for tool-call output to separate from thinking tokens.
* **Agentic coding.** The largest gains over GLM-5.2 are on long-horizon coding tasks: Terminal Bench 3.0 jumps from 4.6 to 28.3 and DeepSWE v1.1 from 46.2 to 66.9 on Z.ai's measurements.
* **1M token context.** 1M tokens input, \~128K output — budget KV cache memory separately from weights.
* **Vulnerability discovery.** Z.ai reports the model surfaced 2,436 findings across 269 open-source projects as post-training scaled, 1,097 of them medium-to-high severity.

## Caveats

* **Custom license, not MIT.** Companies with >\$10B revenue over 12 months need a Z.ai security review before production deployment. GLM-5.3-Flash (`320B`) remains MIT-licensed if you need permissive terms.
* **Benchmarks are vendor-reported.** All figures above are Z.ai's own, measured with their harness settings. Wait for independent evaluations before treating the coding scores as settled.
* **Runtime flags may change.** GLM-5.2 uses `--reasoning-parser glm45` and `--tool-call-parser glm45`; GLM-5.3 likely needs equivalent flags, but confirm against the model card and your serving runtime's docs.
* **Thinking cannot be disabled.** Any code that sets `thinking.type: "disabled"` must switch to `enabled` with `reasoning_effort: "low"` before upgrading to GLM-5.3.

## FAQ

> [accordion] Is GLM-5.3 released?
>
> Yes — weights went live on Hugging Face at [zai-org/GLM-5.3](https://huggingface.co/zai-org/GLM-5.3) on approximately 2026-08-27. The model is also available through the Z.ai API, GLM Coding Plan, and ZCode.

> [accordion] What is the difference between GLM-5.3 and GLM-5.2?
>
> Post-training only — the pretrained base is identical, so the size and hardware profile are unchanged. The gains are concentrated in agentic coding and long-horizon tasks: Terminal Bench 3.0 goes from 4.6 to 28.3 and DeepSWE v1.1 from 46.2 to 66.9 on Z.ai's own measurements. There is also a breaking API change — thinking can no longer be disabled.

> [accordion] How much VRAM does GLM-5.3 need?
>
> Roughly **245 GB at Unsloth 2-bit**, 377 GB at 4-bit, 755 GB at FP8, and 1.5 TB at BF16 for the `753B` stored parameters, before KV cache. The 2-bit build fits a 256 GB Mac. FP8 and BF16 need multi-GPU datacenter servers. A consumer GPU is not a candidate at this tier.

> [accordion] When did the GLM-5.3 weights ship?
>
> Weights went live on Hugging Face at [zai-org/GLM-5.3](https://huggingface.co/zai-org/GLM-5.3) on approximately 2026-08-27, about 2 weeks after the 2026-08-14 announcement.

> [accordion] Can I run GLM-5.3 on Ollama?
>
> Not today — no tag exists. Expect a cloud tag rather than a local pull when it ships: GLM-5.2 appears on Ollama only as `glm-5.2:cloud`, which routes to Z.ai's hosted infrastructure instead of downloading weights. For a GLM model you can actually pull now, `ollama run glm4` gets you the 9B at 5.5 GB. GLM-5.3-Flash community GGUFs are available at AtomicChat/GLM-5.3-Flash-GGUF.

> [accordion] Will my GLM-5.2 setup keep working on GLM-5.3?
>
> Only if you are not disabling thinking. GLM-5.3 rejects `thinking.type: "disabled"` and the request fails, so any client relying on non-thinking mode has to move to `enabled` with `reasoning_effort: "low"` first. Reasoning depth is otherwise controlled by `low`, `high`, or `max`, defaulting to `max`.

> [accordion] Is GLM-5.3 open source?
>
> No — GLM-5.3 ships under a custom "glm-5.3" license, not MIT. Companies with >\$10B revenue over 12 months need a Z.ai security review before production use. Open weights and open source are not the same thing. GLM-5.3-Flash (`320B`) remains MIT-licensed if you need permissive terms.

> [accordion] How do I use GLM-5.3 from another machine?
>
> Serve it on any OpenAI-compatible runtime, then pair the [Tokios connector](https://docs.tokios.com/quickstart.md) so the machine holding the GPUs needs no inbound ports. You call `https://api.tokios.com` with an `sk-tok-…` key from any OpenAI- or Anthropic-compatible client, sending your deployment name in the `model` field rather than the upstream model id.

> [card] [GLM family](https://docs.tokios.com/models/glm.md)
>
> Run a verified GLM model today, from the 9B up to GLM-5.3.

> [card] [Model fit](https://docs.tokios.com/guides/model-fit.md)
>
> Estimate the model and context size your hardware can hold.

> [card] [Quickstart](https://docs.tokios.com/quickstart.md)
>
> Pair the connector and register a local deployment.

> [card] [Quantization and hardware](https://docs.tokios.com/models/quantization-and-hardware.md)
>
> What a model's release formats mean for your hardware.


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