How to Run GLM 5.2 on Ollama: Cloud Setup Guide (2026)

What GLM 5.2 Is and Why Ollama Runs It in the Cloud

GLM 5.2 is an open-weight large language model from Z.ai, the renamed consumer and enterprise arm of Zhipu AI, a Beijing-based lab. The model uses a mixture-of-experts architecture with 744 billion total parameters and roughly 40 billion active per token across 384 experts, built on a DeepSeek Sparse Attention mechanism and pretrained on 28.5 trillion tokens. Z.ai released the weights on Hugging Face at `zai-org/GLM-5.2` under an MIT license, more permissive than the custom terms some earlier GLM releases shipped under. The model targets long-horizon coding: large refactors, multi-file changes, and agentic tasks that run for hours instead of a single prompt-response exchange.

The reason GLM 5.2 only shows up on Ollama as a cloud model comes down to the same math that applies to Kimi K2. At 1-bit quantization, the smallest practical version still needs around 223 GB of combined RAM and VRAM, and the full unquantized model sits closer to 1.5 TB. Ollama's `:cloud` tag sidesteps that entirely. `ollama run glm-5.2:cloud` sends your prompt to Z.ai's infrastructure through Ollama's servers and streams the response back, using the same command syntax as a model that actually lives on your disk.

Z.ai has shipped several GLM generations in 2026. Here's what's live on Ollama as of June 2026:

For most people searching for "GLM 5.2 Ollama" today, `glm-5.2:cloud` is the only option in Ollama's official library. It also has the largest context window in the GLM line by a wide margin. GLM 5.2 includes an effort-level control with High and Max settings, trading latency and compute cost for deeper reasoning on harder coding problems, similar in spirit to the reasoning-effort parameters other frontier APIs expose.

Set Up Ollama Cloud and Run GLM 5.2

Running GLM 5.2 through Ollama takes three steps: install Ollama, sign in, and run the model. Nothing here downloads a multi-hundred-gigabyte file. The whole setup takes under five minutes on any machine with a working internet connection.

Step 1: Install Ollama

# Linux and macOS, one-command installer
curl -fsSL https://ollama.com/install.sh | sh

On Windows, download the installer from ollama.com/download, or use winget:

winget install Ollama.Ollama

Verify the installation:

ollama --version
# Expected: ollama version 0.6.x or higher

Step 2: Sign In to Ollama Cloud

ollama signin

This prints a sign-in URL and opens your browser. Create a free account at ollama.com, or log in if you already have one, then approve the device. The terminal confirms with a message similar to:

Signing in to ollama.com...
Signed in as your-username

Step 3: Run GLM 5.2 from the Terminal

ollama run glm-5.2:cloud

Ollama fetches a small manifest, a few KB rather than the model weights, since inference happens remotely, then drops you into a prompt:

pulling manifest
pulling 7c2a9f1e... 100% ▕████████████████▏  4.2 KB
success
>>> Send a message (/? for help)

Type a prompt to test it:

>>> Refactor this Python function to use type hints and explain the change.

The first response after signing in can take 10-30 seconds while Ollama establishes the cloud session. After that, responses stream back at normal speed.

Step 4: Verify the Model

ollama list

`glm-5.2:cloud` appears in the list at a few KB rather than hundreds of gigabytes. That's expected: this is a cloud passthrough entry, not a downloaded model.

Switching Between Local and Cloud Models

`ollama run` works the same way for local and cloud models, so you can keep both on one machine. Pull a small local model alongside GLM 5.2:

ollama pull qwen3.5:8b

`ollama list` now shows both `qwen3.5:8b` (a multi-gigabyte local download) and `glm-5.2:cloud` (a manifest-only cloud entry). Switch between them by changing the model name in `ollama run` or in your application's API request, keeping a fast local model for routine tasks and reserving GLM 5.2's 1M context and effort-level control for harder, longer-running jobs.

Running GLM 5.2 Locally Instead of in the Cloud

If you have the hardware, GLM 5.2 can run entirely on your own machine, just not through Ollama's official library yet. Unsloth publishes dynamic GGUF quantizations of the model that work with llama.cpp and Unsloth's own inference server.

Memory requirements by quantization

The full, unquantized model is roughly 1.5 TB. The 2-bit dynamic quant (`UD-IQ2_M`) is the practical starting point: Unsloth describes it as the best balance of accessibility and accuracy, and it runs on a single 24 GB GPU paired with 256 GB of unified memory, the kind of setup a high-end Mac Studio provides, or a 24 GB GPU plus 256 GB of system RAM using MoE layer offloading.

Download and run with Unsloth

pip install unsloth

Download the GGUF weights from Hugging Face (`unsloth/GLM-5.2-GGUF`), then start the inference server:

unsloth studio -H 0.0.0.0 -p 8888

This serves a local OpenAI-compatible API and a chat UI at `http://127.0.0.1:8888`. For a connection reachable outside your own machine, add HTTPS:

unsloth studio --secure

This local setup is separate from Ollama. If your goal is specifically to use Ollama's command syntax and ecosystem, the `glm-5.2:cloud` tag from the previous section is currently the only way to do that, and it's the simpler option for almost everyone.

Use GLM 5.2 in Your Own Scripts and Agents (API Access)

Beyond the interactive `ollama run` session, GLM 5.2's cloud tag is reachable through Ollama's REST API. Any tool that already talks to a local Ollama instance, or to the OpenAI API format, can use it with a one-line model name change.

Generate an API Key

Visit ollama.com/settings/keys while signed in, click "Create API key", and copy the value. Set it as an environment variable:

export OLLAMA_API_KEY=your_api_key_here

Call GLM 5.2 from the Local Endpoint

curl http://localhost:11434/api/chat -d '{
  "model": "glm-5.2:cloud",
  "messages": [
    { "role": "user", "content": "Summarize the difference between GLM 5.1 and GLM 5.2 in two sentences." }
  ],
  "stream": false
}'

Expected output (truncated):

{
  "model": "glm-5.2:cloud",
  "message": {
    "role": "assistant",
    "content": "GLM 5.2 expands the context window from GLM 5.1's 198K to a usable 1M tokens, adds DeepSeek Sparse Attention, and introduces effort-level control for trading latency against reasoning depth on harder coding tasks."
  },
  "done": true
}

Call GLM 5.2 Directly from ollama.com

For a server or serverless function without a local Ollama install, send requests straight to ollama.com using your API key:

curl https://ollama.com/api/chat \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
  -d '{
    "model": "glm-5.2:cloud",
    "messages": [{ "role": "user", "content": "Hello" }]
  }'

Python Example

from ollama import Client

client = Client(host="https://ollama.com", headers={"Authorization": "Bearer " + api_key})

response = client.chat(
    model="glm-5.2:cloud",
    messages=[{"role": "user", "content": "Plan a migration from a Flask monolith to FastAPI microservices."}],
)
print(response["message"]["content"])

OpenAI-Compatible Endpoint for Existing Agent Tools

Ollama exposes an OpenAI-compatible layer at `http://localhost:11434/v1`, the same endpoint used in the Hermes Agent and OpenClaw setups. Point that configuration at `glm-5.2:cloud` instead of a local model name, and the agent runs on GLM 5.2's 1M context window without any other config changes:

model:
  default: glm-5.2:cloud
  provider: custom
  base_url: http://localhost:11434/v1
  context_length: 1000000

Troubleshooting

Frequently Asked Questions