The Full GLM 5.3 Course.

The Half-Finished Problem.

You don't need an AI that answers questions. You need one that finishes the job.

A new model from Z.ai.

GLM 5.3 launched on 14 August 2026. And there's one detail in the launch that changes how you should think about every AI model from now on.

Same brain. Different worker.

It's the exact same base model as GLM 5.2 — same size, same architecture, same pre-training. Every single improvement came from post-training.

Nothing about the core model changed. They just taught it how to work.

Learning things vs learning to work.

This is the most useful idea in the whole course, and it takes ten seconds to get.

The student who did an internship.

GLM 5.2 was a smart student who had only ever done homework. GLM 5.3 is that same student after a month of doing real jobs.

Same brain. Completely different worker.

Real units of professional work.

Z.ai moved away from coding puzzles and towards tasks that look like a real day at work — some of them several days of work for an experienced engineer.

They built a factory that makes the jobs.

They couldn't hand-build enough realistic tasks, so research agents turned real work into runnable environments — and a judge agent attempted each one to check it was even solvable.

It spent a month being judged on real outcomes.

You'll feel it when you use it: this model checks itself before it says it's done. Give it something to check against and the quality jumps.

Ten extra words. Biggest free quality upgrade available to you — I'll show you exactly where to put it in the first build.

Terminal Bench 3.0: 4.6 to 28.3.

It drops the AI into a computer, gives it a real task, and sees whether it can finish the whole thing alone — up to 600 turns, a ten-hour window.

Four more tests. Same story.

Fixing real software problems, endurance on long problems, automating multi-step work, and a hard agent test.

The longer the job, the bigger the jump.

Short tests moved a little. Long tests moved enormously. That tells you exactly what to give it.

So give it long jobs. That's where the whole upgrade lives.

Labs grade their own homework.

Almost every number above came from Z.ai themselves. Healthy scepticism is fair — every lab does this.

GDPval: real professional work.

It measures the kind of tasks people get hired to do. On the one test in the whole launch Z.ai didn't touch, the open model came out on top.

It does not win everything.

A course that only shows you the wins is setting you up for disappointment.

So the truthful claim isn't "best open model at everything". It's this: the strongest open model at long-horizon agent work.

Higher score. Half the tokens.

Most open models think in circles and burn your allowance doing it. This one flipped that — and on a daily limit, that's the difference between running out at lunchtime and working all day.

Efficient tokens are worth more than plentiful tokens. That stacks with two more tricks I'll show you later.

Download it. Sign in. That's it.

Go to zcode.z.ai, download the desktop app for Mac or Windows, install it like any normal app, and sign in with an email. A brand new email works fine.

One folder, one project.

ZCode works on folders — everything it builds lands in the folder you open. Make a new one on your desktop, name it clearly, and open that as your project.

Pick GLM 5.3, not turbo.

There's a dropdown in the composer. Turbo is the faster, lighter model and it's fine for quick questions — for everything in this course, stay on 5.3. That's the one that made the jump.

What you're watching: the real model dropdown in ZCode. GLM-5.3 ticked, GLM-5.2 underneath it, and GLM-5-Turbo below that. Stay on the top one.

Effort: low, high, max.

Low answers fast with light thinking. Max thinks as deeply as it can before it does anything — and Z.ai themselves recommend max for real building work.

What you're watching: the effort menu open in the real app — Low, High, Max — with Max ticked, sitting right next to the model name.

A lead capture page. The front door.

Highest-value first project you can do — it's the thing that turns a visitor into a name in your inbox. Effort on max, fresh folder, then type this and change the business to yours.

What you're watching: that exact prompt, in the real app. It thinks, loads its own front-end design skill, writes index.html, then builds a little server so the form has somewhere to save to — none of which I asked for by name.

Then it tested its own form.

Watch the end of that run: it starts the server, opens the page, scrolls to the form, clicks submit, and checks a record actually landed on disk. Here's what was in the folder afterwards.

That's the trained behaviour from part one. Your prompt said "test that the form actually saves" — so it did, and proved it.

Seven builds. Real numbers.

Every demo further down this page was produced by GLM 5.3 from the exact prompt shown above it — nothing hand-edited. Here's what each one actually cost.

Describe outcomes, not steps.

This model was trained to plan. Planning is the thing that got six times better. Micro-manage every step and you throw the entire upgrade away.

Always give it a way to check itself.

One line. Ten extra words. The biggest free quality upgrade available to you — because verifiers are literally what this model was trained against.

Goal mode: hand it a finish line.

Normal chat is a conversation — you spot the problems, you hold the plan. Goal mode loops on its own until the goal is verified as met. Not until it thinks it's probably done.

What you're watching: goal mode running the client tracker brief in the real app — it plans, writes the file, then opens its own build in a browser pane to test it.

What you're watching: three real clients going in, the overdue one turning red on its own, a status change, and the whole thing still there after a full page reload.

Start it here. Check it from your pocket.

ZCode lets you monitor and steer a long-running task from your phone — so you stop being the operator who sits and watches, and become the manager who checks in.

One million tokens of context.

That's like handing it several full books at once and having it hold every page while it works. Most people type two-sentence prompts into a model that could hold a library.

What you're watching: it reads the old page first, then works through the problems one at a time — dead link, bloated image, marquee, unlabelled form.

What you're watching: a 1999-era plumbing page — dead links, a 4MB image, a marquee — rebuilt, with the "what I changed and why" list it wrote at the bottom.

A content engine in your voice.

If you want it to write like you, put your voice in the project — drop ten pieces of your own writing in a folder first. Text is cheap, so this one barely dents your allowance.

What you're watching: it reads the ten writing samples, works out the patterns, then drafts and checks each email against them before showing you anything.

What you're watching: it names the actual patterns it found — sentence length, the writer's habit of opening with "Morning", no exclamation marks — then writes to them and shows its working.

Your customer feedback, ranked.

Gather whatever you have sitting around — support emails, reviews, survey answers, notes from calls — and put it all in one folder. This used to mean hiring someone for a week.

What you're watching: every comment grouped into themes and counted in the real app, then built into the page — with the count checked before it finishes.

What you're watching: 28 pieces of feedback turned into ranked themes with the real customer words underneath — and a praise section, in one run. Next month you drop in new feedback and run it again.

A planner built around your week.

Small build, big habit change — and the one you'll probably open every day. A planner built around your week beats one built around the average of a million people's weeks.

What you're watching: the best clip on this page. It builds the planner, tests its own add button, finds the click isn't landing, diagnoses why, and retries a different way — nobody told it to.

What you're watching: real tasks going into real days, the done counter moving, and the whole week still there after a reload.

An app that lives on your phone.

Not an App Store app — no developer account, no approval, no two-week wait. A web app that installs to your home screen with its own icon, opens full screen, and works offline.

What you're watching: it writes the app, the manifest and the service worker, generates the icons, then checks the whole thing on a phone-sized screen.

What you're watching: the real build on a 430-pixel phone frame — today's jobs, a job being added, the week's earnings screen. Big buttons, one hand, no browser bar.

Four taps and it's an icon.

While it's building, ask it one follow-up: "Give me the simplest way to open this on my phone from my computer, in plain steps I can follow without any technical knowledge."

Before you get carried away.

The front-end quality genuinely surprised people.

This used to be the weak spot for open models — logic fine, pages that looked like 2023. In testing after launch it built things people didn't expect.

Three things stack to double your day.

Most people never notice any of these. Together they're the difference between running out at lunchtime and working all day.

A long conversation inside one project is cheaper per message than ten short conversations across ten projects. That's the opposite of what most people assume.

Keep your setup. Swap the engine.

Z.ai built their endpoint to be compatible with Anthropic's format, so if you already use Claude Code you can point it at GLM 5.3 with a few settings and no special software. OpenCode had it live on launch day with the full million-token context.

One file. Two minutes. Every job after that.

Create a plain text file in your project called instructions, write the rules you want followed on every job, and start every prompt in that project with "read the instructions file first".

That's a skill. Not a fancy one, but a real one — and with a million tokens of context it can be genuinely detailed. Build one per project and your output gets consistent instead of random.

The job that was too expensive to run.

Point an existing workflow at GLM 5.3 and it runs on a model using less than half the tokens. The automation you ran occasionally becomes the one you run constantly.

Avoid these and you're ahead of most people.

Four things this release doesn't do.

What's actually in the way.

A home screen for your AI workers.

One dashboard where every agent you use lives side by side, all reading and writing to one shared memory — so nothing gets re-explained and nothing gets lost between tools.

GLM 5.3's role in a system like this is specific: the high-volume, long-task engine. Strongest open model at long agent work, half the tokens, plugs into Claude-Code-compatible setups in ninety seconds.

Every model you use is nowhere near its ceiling.

Same base model, one month of post-training, six times better at long tasks. Post-training is cheaper and faster than pre-training — so these jumps keep coming, from several labs at once.

What you built, and what you know.

Run build one before the day ends.