Imagine you have a really smart friend named GLM. He can write stories, answer questions, and even make pretty documents. Right now he lives far away — at Z.ai's house — and every time you want to talk, you have to send him a letter through the mail and wait.

What if you could invite GLM to live in your house? Then he'd always be there. No mail. No waiting. And — best part — you could give him a desk, some pens, and a recipe book, and he'd start making the same kind of pretty reports Z.ai shows off.

This guide walks you through that, one tiny step at a time. Grown-up words are explained with kid words. Every step ends with "you did it" so you always know when to high-five yourself.

Before we start: meet the four friends

Picture four friends who all need to show up at your house for a party:

• GLM — the smart brain. He writes the words.
• Ollama — the front door. He's the one who actually lets GLM inside your computer.
• Open WebUI — the desk and chair GLM sits at. It's the screen with buttons that you click.
• Toolbox — pens, paper, scissors, glue. Without these, GLM can only talk. With these, he can make things.

Got the picture? Okay, let's invite them over one at a time.

Step 1 — Put in the front door (install Ollama)

Ollama is the front door of your computer. Without it, GLM has nowhere to walk in. The good news: it installs itself with one command.

Open your terminal (that black box where you type stuff). On a Mac, press Cmd + Space, type terminal, and hit Enter. On Windows, search for "PowerShell." Then paste this in and press Enter:

curl -fsSL https://ollama.com/install.sh | sh

Your computer will think for a minute, download some files, and tell you when it's done. If you see something like "Ollama is now running" or just no red error text — you did it.

Step 2 — Invite GLM inside (download the model)

Now that the door is in, you need to actually call GLM over. He lives in a big library called Hugging Face. Tell Ollama to fetch him:

ollama pull hf.co/unsloth/GLM-4.6-GGUF:TQ1_0

This one takes a while — like, "go make a sandwich" while. GLM is a chunky boy (~73GB). When the progress bar hits 100% and the prompt comes back, you did it.

Quick note: if your computer doesn't have a lot of memory (less than 32GB of RAM or under 24GB of video card memory), grab the smaller cousin instead:

ollama pull hf.co/unsloth/GLM-4.5-Air-GGUF:Q4_K_M

He's smaller, faster, and almost as smart.

Step 3 — Say hi to GLM (test it works)

Before we give him a desk, let's just check he's awake. Type:

ollama run hf.co/unsloth/GLM-4.6-GGUF:TQ1_0

You'll see a little >>> prompt. That means GLM is listening. Type: Hi! What's 2 plus 2? and press Enter. If he answers — even a weird answer — you did it. GLM is alive in your house.

Type /bye to send him to his room for now.

Step 4 — Give GLM a desk (install Open WebUI)

Right now, talking to GLM means typing in that black terminal box. That's no fun. Let's give him a nice desk with buttons and a screen. That desk is called Open WebUI.

Make sure Python is installed first (it usually is on Mac; on Windows grab it from python.org). Then in your terminal:

pip install open-webui
open-webui serve

It'll print some text and tell you it's running on something like http://localhost:8080. Open your browser (Chrome, Safari, whatever) and go to that address. You'll see a chat screen that looks suspiciously like the one at z.ai. You did it. GLM has a desk now.

If you go to Settings → Connections, you'll see Ollama is already auto-detected. That's because both friends are at the same party.

Step 5 — Hand GLM the toolbox (install the document libraries)

Here's the part most people miss, and it's the secret sauce. GLM by himself can only talk. He can't actually save a Word file or draw a chart. He needs tools — just like a chef needs a stove and a pan.

Open a new terminal window (or stop the open-webui one with Ctrl+C and restart it later) and install these tools. Each one is a different appliance in GLM's kitchen:

pip install python-docx          # the Word-document typewriter
pip install reportlab            # the PDF-printing press
pip install openpyxl             # the Excel spreadsheet maker
pip install python-pptx          # the PowerPoint slide projector
pip install matplotlib seaborn   # the chart-drawing crayons
pip install pandas               # the calculator
pip install weasyprint           # an HTML-to-PDF toaster (optional but nice)

When all of those finish installing without red errors — you did it. GLM's kitchen is fully stocked.

Step 6 — Write the recipe book (make skill files)

This is the magic step. A chef with tools but no recipes makes a mess. So we write GLM a little recipe book — one recipe per kind of document.

Make a folder on your computer, like ~/.glm-skills/, and inside it put plain text files. Each one tells GLM the rules for that kind of document. For example, pdf.md might say:

# How to make a PDF

- Use the reportlab library.
- Every paragraph must have at least 3 sentences.
- Never put a page break in the middle of a section.
- For Chinese characters, register Noto Serif SC first.
- Always save the .py script before running it.

Then in Open WebUI, go to Settings → Advanced → System Prompt, and paste the contents of the recipe that matches what you want. (If you want a Word doc, paste docx.md. If you want a PDF, paste pdf.md.) Now whenever GLM writes that kind of document, he follows your rules. You did it. GLM knows how the house runs.

Step 7 — Ask for a report (the fun part)

Back in Open WebUI, type something like:

"Write me a 3-page PDF briefing about why the sky is blue, with a cover page and three sections."

If everything's wired up — GLM is awake, the libraries are installed, and the recipe is loaded — GLM will write a Python script, run it, and produce an actual .pdf file you can open and read. You did it. You just reproduced a Z.ai-style polished report on your own computer, with no API bill.

Quick recap — the party in order

1. Install the door → curl -fsSL https://ollama.com/install.sh | sh
2. Invite GLM in → ollama pull hf.co/unsloth/GLM-4.6-GGUF:TQ1_0
3. Wave hello → ollama run ... and ask "what's 2+2?"
4. Set up the desk → pip install open-webui && open-webui serve
5. Stock the kitchen → pip install python-docx reportlab openpyxl python-pptx matplotlib
6. Write the recipe book → make ~/.glm-skills/*.md files, paste one into the system prompt
7. Order a report → ask Open WebUI for a PDF and watch it appear

Do these seven steps in order and you'll have a working local GLM setup before bedtime.

So is the Z.ai frontend open source?

Honest answer: no, the actual chat.z.ai website code is not open source. You can't just download the exact screen you see when you log into Z.ai.

But here's what Z.ai has given away for free (and it's a lot):

• The GLM model weights — GLM-4.5, 4.6, 4.7, and GLM-5 are all on Hugging Face under the MIT license. This is the brain itself. Anyone can use it commercially.
• The inference code — at github.com/zai-org/GLM-4.5, you get the Python code that knows how to run the model.
• Z.ai Coding Plugins — at github.com/zai-org/zai-coding-plugins, a marketplace of plugins for Claude Code-style agents.
• Synapse — at github.com/zai-org/Synapse, a self-hostable AI workspace with shared conversations, memory, and MCP tools. This is the closest thing Z.ai has released to their chat frontend, but it's a separate product, not the chat.z.ai code.

What's not open: the proprietary "skills" system that turns a plain chat answer into a polished multi-page report with the right fonts, page breaks, and cover pages. That part you build yourself with Step 6 above.

So the realistic move is: take Z.ai's open model, run it on your machine, give it the open-source Open WebUI frontend, and write your own skill files. You end up with something that works like Z.ai, even if it doesn't look exactly like Z.ai. And honestly — once you've tuned your skill files for a few weeks, yours might be better, because they'll be exactly tuned to the documents you care about.

How to tell GLM exactly what you want (the spec sheet)

Here's the part nobody explains: a model can't read your mind. "Make me a report" produces a different document every time. To get the polished, repeatable output you're after, you have to brief GLM the same way you'd brief a junior designer — with specific numbers and specific rules, not adjectives.

You can put the brief in two places. In the user prompt for one-off requests where every report is different. Or in the skill file for repeatable defaults where you want all your PDFs to look the same. The mental model: skill file = house style guide; user prompt = the specific assignment.

The 11 things to always specify

Every brief should answer these. Skip one and the model fills it in with a guess — usually a bad one.

1. Length — total page count, word count, and words-per-section. "8 pages" is too vague; "8 pages, ~3,000 words, ~400 words per body section, 4 body sections" is briefable.
2. Cover page — yes or no, layout (full-bleed photo, solid color, or centered title only), and whether it should look "glossy" (gradient/photographic) or "minimal" (typographic only).
3. Table of contents — yes or no, and if yes, how deep (just H1s, or H1 plus H2).
4. Headers and footers — what goes in the header (report title? section name?), what goes in the footer (page numbers? copyright line? date?).
5. Page numbers — format (1, 2, 3 or i, ii, iii for front matter), starting position (cover doesn't count? start at TOC?), and alignment.
6. Typography — heading font, body font, and sizes. If you don't pick, the model picks for you, usually badly.
7. Color palette — primary, accent, and background. Use hex codes, not adjectives. "Professional blue" means something different to every model on every day.
8. Section structure — what sections, in what order, with what each one is about.
9. Visual elements — charts? tables? callout boxes? sidebars? Specify which and where.
10. Tone and audience — executive, technical, or general public.
11. Output format and path — PDF, DOCX, XLSX, or PPTX, plus the exact save location on disk.

A copy-paste spec template

Here's a template you can fill in and paste into the user prompt or your skill file. Treat the bracketed values as the only things you change.

# REPORT SPEC

Length: 8 pages total, ~3,000 words, ~400 words per body section
Audience: executive (non-technical)
Tone: confident, concise, no hedging

Cover:
  - Style: glossy, full-bleed gradient background (#0A2540 to #1E3A8A)
  - Title centered, white, 32pt
  - Subtitle below in lighter weight, 14pt
  - Date and author in bottom-right corner, 10pt

Table of contents: yes, H1 only, on its own page after cover

Headers: report title on left, section name on right
Footers: page number centered ("Page 3 of 8"), copyright line on left

Page numbers: arabic, start at 1 on the first body page
  (cover and TOC don't count)

Typography:
  - Headings: Noto Sans SC, 18pt, bold, #0A2540
  - Body: Noto Serif SC, 11pt, #1F2937
  - Captions: Noto Sans SC, 9pt, italic, #6B7280

Color palette:
  - Primary: #0A2540 (deep navy)
  - Accent: #F59E0B (amber)
  - Background: #FFFFFF
  - Callout background: #FEF3C7

Sections (in order):
  1. Executive Summary — 200 words
  2. Market Context — 400 words + 1 bar chart
  3. Key Findings — 800 words + 2 tables
  4. Recommendations — 400 words
  5. Appendix — data tables, no word count

Visual elements:
  - 1 bar chart in section 2 (matplotlib, accent color)
  - 2 tables in section 3 (alternating row shading)
  - 3 callout boxes for key stats (amber background)

Output: PDF, saved to /home/me/reports/q4-summary.pdf

How to actually make the cover "glossy"

"Glossy" is a vague word that means different things to different models. To get the look you actually want, specify these four things instead of just the word:

• Background type: full-bleed photo, gradient, solid color, or texture.
• Gradient direction (if gradient): "top-to-bottom, 135 degrees" or "radial from center".
• Hex codes for both endpoints of the gradient.
• Title treatment: shadow yes/no, embossed yes/no, all-caps yes/no.
• Photo source (if full-bleed): "from Unsplash, query: modern cityscape at dusk" — otherwise the model will guess, and it'll guess badly.

A typical glossy cover brief looks like this:

Cover style: glossy, full-bleed gradient
Gradient: 135 degrees linear, from #0F172A (top-left) to #1E40AF (bottom-right)
Title: "Q4 2026 Market Review", centered, 36pt, white,
       slight drop shadow (rgba(0,0,0,0.3), 2px offset)
Subtitle: "Prepared for the Board of Directors", centered, 14pt, #E5E7EB
Bottom strip: thin amber bar (#F59E0B), 4px tall, full width, 24px from bottom edge
Date: "October 2026", bottom-right, 10pt, white

Where each spec lives

Two example briefs side by side

Example A — short and opinionated:

"Make a 4-page PDF briefing on lithium supply chains. Glossy cover with deep navy gradient. TOC. Executive summary plus 3 body sections plus recommendations. Page numbers in footer, centered. Save as lithium.pdf."

Example B — long and fully spec'd:

Use the template above, fill in every field, paste the whole thing into the chat.

Both work. Example A produces a good-but-generic report. Example B produces a report that looks like a human designer made it. The difference between the two is roughly the difference between a template you found on Etsy and one a brand agency would charge you five figures for.

Wrapping up

Think of it like this: the model is the brain, the agent loop is the hands, the Python libraries are the typewriter, and the skill files are the style guide. Skip any one of those four and the output drops a tier. Get all four right and you'll be producing Z.ai-quality deliverables on your own hardware, on your own data, with no API bill.

Start with Steps 1 through 3 tonight. Get one goodnight-answer from GLM. Then come back tomorrow and finish Steps 4 through 7. By the end of the week, you'll have your own report factory.

If you've watched Z.ai hand back a beautifully formatted PDF or Word document in seconds and wondered "can I do that on my own machine?" — the answer is yes, but you have to understand that the magic isn't in the model alone. Polished reports come from model + agent loop + document libraries + style instructions working together. The model is just one ingredient.

This walkthrough covers the full stack: how to install a local GLM runtime, which quant to pick, how to wrap the model in an agent that can call tools, and the formatting rules that turn a wall of text into something you'd be proud to ship to a client. Let's build it piece by piece.

1. Pick your local runtime

There are four mainstream ways to run GLM locally. Which one you choose depends almost entirely on your hardware — there's no "best" runtime, only the right one for your machine.

For most people starting out, Ollama is the right call. It installs in one command, autodetects your GPU, and exposes an OpenAI-compatible endpoint that every agent framework on earth knows how to talk to. You can always graduate to vLLM later if you need higher throughput.

2. Pull the GLM model

GLM comes in a few sizes. The community-maintained Unsloth quants on Hugging Face are currently the most reliable GGUF files, and Ollama can pull them directly via the hf.co/ prefix:

# Smaller Air variant — fits on 24–48GB VRAM with quantization
ollama pull hf.co/unsloth/GLM-4.5-Air-GGUF:Q4_K_M

# Full GLM-4.6 (better quality, needs ~73GB for Q4)
ollama pull hf.co/unsloth/GLM-4.6-GGUF:TQ1_0

# Then run it
ollama run hf.co/unsloth/GLM-4.6-GGUF:TQ1_0

GLM-4.6 expanded the context window from 128K to 200K tokens, improved coding benchmarks, and — most relevant for us — refined its writing style to align more naturally with human preferences. If you have the VRAM, go straight to 4.6. If you're on a 24GB consumer card, the Air variant is a perfectly serviceable stand-in. Mac users should swap Ollama for MLX and call mlx_lm.load("zai-org/GLM-4.6") instead.

3. Expose it as an OpenAI-compatible API

Here's the underappreciated part: Ollama already exposes your local model on http://localhost:11434/v1 using the OpenAI chat completions schema. That means any agent framework built for OpenAI — which is basically all of them — will work with your local GLM for free, with zero code changes. Verify the endpoint works:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"hf.co/unsloth/GLM-4.6-GGUF:TQ1_0","messages":[{"role":"user","content":"hi"}]}'

If you get JSON back with a choices array, you're in business.

4. Wrap GLM in an agent loop with tools

This is the part most people skip, and it's the real secret to polished reports. Z.ai doesn't just ask the model for a report. It gives the model tools — file-write access, web search, code execution — and a skill system: Markdown instruction files that define exactly how each document type should be formatted. You can reproduce both halves locally.

Easy path — use an existing agent UI

• Open WebUI (pip install open-webui) — connects to Ollama automatically, has a community marketplace of "tools" (Python functions the model can call), including write_docx, write_pdf, and friends.
• Cline or Roo Code (VS Code extensions) — point them at your local Ollama endpoint, hand them file-write and terminal tools. GLM-4.6 and 4.7 are explicitly tuned for these agent frameworks and the difference is visible.
• Continue.dev — similar pattern, good for inline workflows inside your editor.

Custom path — write your own agent loop

• OpenAI Agents SDK (pip install openai-agents) — point base_url at Ollama, register tools as plain Python functions.
• LangGraph or smolagents — more control over multi-step reasoning and tool sequencing.

A minimal client looks like this:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # any non-empty string works
)

resp = client.chat.completions.create(
    model="hf.co/unsloth/GLM-4.6-GGUF:TQ1_0",
    messages=[{"role": "user", "content": "Write me a 3-section briefing on lithium supply chains."}],
)
print(resp.choices[0].message.content)

From here, the only limit is which tools you wire up.

5. Install the document libraries

The actual file production is done by Python libraries the model calls as tools, not by the model itself. The model decides what goes in the report; the libraries make it look good. Install the full stack:

pip install python-docx          # Word documents
pip install reportlab            # PDFs with full layout control
pip install openpyxl             # Excel spreadsheets
pip install python-pptx          # PowerPoint slides
pip install matplotlib seaborn   # charts and figures
pip install pandas               # data manipulation

# Optional but very useful:
pip install weasyprint           # HTML → PDF for prettier layouts
pip install jinja2               # templating for repeatable report structures

Once these are installed and exposed as tools the model can invoke, you've closed the gap between "the model produced text" and "the model produced a deliverable."

6. Mirror the "skills" pattern

The single biggest reason Z.ai's reports look polished is the skill files — Markdown instructions that tell the model exactly how to format each document type. Cover page recipe, font choices, paragraph depth rules, page-break rules, character safety rules. Without these, the model produces generic Markdown and you get a mediocre PDF. With these, every report follows the same high bar.

You can build a minimal version on disk:

~/.glm-skills/
  ├── docx.md         # Word rules: fonts, TOC, no page breaks mid-section
  ├── pdf.md          # PDF rules: ReportLab, CJK font registration, character safety
  ├── xlsx.md         # Spreadsheet rules: header styling, freeze panes
  └── pptx.md         # Slide rules: one idea per slide, color palette

Each file is just Markdown the model reads as system context when asked to produce that document type. When the user says "make me a PDF," you load pdf.md into the system prompt, then let the model emit Python that calls ReportLab. You can harvest real skill files from open-source agent frameworks — Z.ai has open-sourced model weights and several tools at github.com/zai-org, and the structural pattern is easy to adapt.

7. Add the "polish" rules

These are the actual differentiators. Steal them verbatim — they're what separates a generic model output from a Z.ai-style deliverable:

• Content depth. Every section ≥150 words, every paragraph ≥3 sentences. No bullet dumps masquerading as analysis.
• Page breaks only between cover ↔ TOC and TOC ↔ body, never mid-section. Mid-section page breaks are the single most common formatting tell that something was generated by a model that didn't have rules.
• Chinese and special characters. Register Noto Serif SC and Noto Sans SC fonts before generating PDFs, or you'll get tofu boxes (□□□) everywhere a CJK character should be.
• Script persistence. Have the model write a .py file first, then you execute it. On failure, edit-and-rerun rather than regenerate the whole thing. This one rule cuts iteration cost 5–10×.
• Two-stage generation. First call an Outline step (just structure), then per-section generation calls. This is how you get long, coherent documents instead of shallow one-shot output where the model runs out of ideas halfway through.

8. A 30-second recipe to start today

If you want to be up and running by tonight, here's the shortest path:

# 1. Install Ollama + pull a GLM quant
curl -fsSL https://ollama.com/install.sh | sh
ollama pull hf.co/unsloth/GLM-4.6-GGUF:TQ1_0

# 2. Install Open WebUI for the agent surface
pip install open-webui
open-webui serve

# 3. Open http://localhost:8080
#    Settings → Connections → Ollama (auto-detected)
# 4. Install the "Document Tools" community pack
#    (docx / pdf / xlsx / pptx writers)
# 5. Add a custom system prompt containing the contents
#    of your skill files

From there, ask Open WebUI something like "Write me a 4-page briefing on grid-scale battery storage economics as a PDF." If the tools are wired up and the skill prompt is loaded, you'll get a real file back — not just text in a chat window.

Wrapping up

The mental model to walk away with: the model is the brain, the agent loop is the hands, the Python libraries are the typewriter, and the skill files are the style guide. Skip any one of those four and the output drops a tier. Get all four right and you'll be producing Z.ai-quality deliverables on your own hardware, on your own data, with no API bill.

Start small: Ollama + one GLM quant + Open WebUI + the document tools pack. Get one clean PDF out of it. Then iterate on your skill files — that's where most of the polish actually comes from, and it's the part you can keep improving forever.