# GLM 5.3 MCP: Tool Calling Tested and One Costly Regression

> Z.AI shipped GLM 5.3 with a 1M context window and stronger agentic tool calling. I ran it against a live MCP server with deeply nested schemas — here is what improved, and the one thing that broke.

**Source:** https://mcpplaygroundonline.com/blog/glm-5-3-mcp-servers  
**Author:** Nikhil Tiwari  
**Published:** 2026-08-26  
**Category:** Development  
**Reading time:** 10 min read

---

TL;DR

-   **GLM 5.3 landed on OpenRouter on 18 August 2026** — 1M-token context, 131K max output, $1.40 / $4.40 per 1M tokens.
-   Across three runs it produced **24/24 schema-valid tool calls** — ahead of GLM 5.2 (20/24) and Claude Haiku 4.5 (23/24).
-   **It ignores structured outputs.** GLM 5.2 returned schema-valid JSON 3/3; GLM 5.3 returned 0/3.
-   It is a reasoning model, so a small `max_tokens` silently truncates tool calls. Give it room.
-   Test it against your own server in [MCP Agent Studio](/mcp-agent-studio) — pick GLM 5.3, connect a server, watch every call.

Z.AI shipped **GLM 5.3** in August 2026, and if you run MCP servers it is worth a look.

The pitch is long-horizon agent work. A _1M-token context window_, 131,072 max output tokens, and reasoning baked in.

But release notes do not tell you how a model behaves against **your** tool schemas. So I tested it.

I pointed GLM 5.3 at a live MCP server with four deeply nested tools. Then I ran the same eight prompts — three times each — through GLM 5.2, GLM 5.1, and Claude Haiku 4.5.

The headline: **GLM 5.3 shapes nested arguments better than any GLM before it**. It also quietly broke something GLM 5.2 did well.

Skip this and you will either underrate the model or get bitten by the regression in production.

In this guide

1.  [What is GLM 5.3?](#what-is)
2.  [How I tested GLM 5.3 MCP tool calling](#how-i-tested)
3.  [GLM 5.3 vs GLM 5.2 vs Haiku 4.5: the results](#results)
4.  [The structured outputs regression](#regression)
5.  [Why GLM 5.3 needs a bigger token budget](#token-budget)
6.  [When to use GLM 5.3 for MCP servers](#when-to-use)
7.  [How to test your MCP server with GLM 5.3](#how-to-test)
8.  [Frequently asked questions](#faq)

## What Is GLM 5.3?

**GLM 5.3 is Z.AI's reasoning model for software engineering and long-horizon agents.** It is the successor to GLM 5.2.

Here is the spec sheet, taken from the OpenRouter model API rather than a marketing page:

Spec

GLM 5.3

GLM 5.2

Context window

1,048,576

1,048,576

Max output

131,072

262,144

Input / 1M

$1.40

$1.19

Output / 1M

$4.40

$3.74

Cached input / 1M

$0.26

$0.22

Structured outputs

Not supported

Supported

Two things stand out. **Max output halved** versus GLM 5.2, and _structured outputs disappeared_ from the supported parameter list.

That second one is not a footnote. I come back to it below, because it changes how you build.

Pricing is up roughly 18% on GLM 5.2. Still cheap next to a frontier model, and cheaper per token than Claude Haiku 4.5 on output.

## How I Tested GLM 5.3 MCP Tool Calling

**Tool selection is the easy part.** Most decent models pick the right tool from a short list.

The hard part is _argument shaping_ — filling a nested JSON schema without violating it.

So I used the MCP Playground [complex test server](/mcp-test-server). Four tools, all with deep nesting, enums, and numeric bounds.

The tools were `create_user_profile`, `process_order`, `analyze_data`, and `configure_workflow`.

I wrote eight prompts, two per tool. Each had one obviously correct tool and enough detail to fill a nested payload.

I ran the full set **three times per model** — 24 calls each — so one lucky pass could not carry a result.

Then I scored three things, in order of how much they matter:

1.  **Tool picked** — did it choose the right tool?
2.  **Schema-valid** — did the arguments pass Ajv validation against the tool's real `inputSchema`?
3.  **Server-accepted** — did the live MCP server actually execute the call without a validation error?

That third check is the one people skip. A call can look fine and still be rejected by the server.

**Want to run this on your own server?** You do not need a script. [Test any MCP server free](/mcp-test-server) in the browser, then switch models mid-chat to compare.

## GLM 5.3 vs GLM 5.2 vs Haiku 4.5: The Results

Eight prompts, three runs, four models — 24 tool calls per model against the live server:

Model

Tool picked

Schema-valid

Server-accepted

Median latency

**GLM 5.3**

24/24

**24/24**

**24/24**

13.2s

GLM 5.2

24/24

20/24

20/24

5.4s

GLM 5.1

24/24

6/24

6/24

9.9s

Claude Haiku 4.5

24/24

23/24

23/24

**3.3s**

**GLM 5.3 got a clean sweep — 24 for 24.** Every call valid, every call accepted by the server, in all three runs.

GLM 5.2 dropped four. Nearly all of them on the same tool, `configure_workflow`, and mostly the same field.

It kept passing an _object_ where the schema wanted a string for `nextStep`. It also passed `null` once for an optional string.

That second one is a classic. _Optional does not mean nullable_, and plenty of models conflate the two.

GLM 5.1 was the real surprise. It picked the right tool all 24 times, then emitted **truncated JSON** on 18 of them.

The arguments simply stop mid-object, with a `finish_reason` of `tool_calls`. Six failures per run, every run. If you are still on GLM 5.1 with nested schemas, check your error logs.

Haiku 4.5 was not perfect either. It dropped one call on the same `nextStep` field that tripped GLM 5.2.

That tells you something useful: **the hardest field in the suite defeated three of four models.** Only GLM 5.3 got it right every time.

The honest caveat: **GLM 5.3 is slow.** Median 13.2 seconds against Haiku's 3.3.

It burned about 12,000 completion tokens across eight calls. GLM 5.2 used under 4,000 for the same work.

That is the reasoning tax. You pay it in latency and output tokens, and you get accuracy back.

## The Structured Outputs Regression

Here is the part that will cost you an afternoon if you upgrade blind.

**GLM 5.3 does not honour `response_format` with a JSON schema.** GLM 5.2 does.

I sent both models the same strict schema, three times each, asking for a city and a population.

GLM 5.2 returned clean, schema-valid JSON on all three runs. Every time, exactly the requested shape.

GLM 5.3 returned **zero valid responses out of three**. It wrapped output in markdown code fences and invented its own field names.

Instead of `city` it returned `location`. Instead of a number for `population`, it returned a nested object.

Do not swap GLM 5.2 for 5.3 in a JSON pipeline

If any part of your stack relies on `response_format: json_schema`, GLM 5.3 will break it silently. Your parser will start throwing on markdown fences. Tool calling is unaffected — only structured outputs.

This tracks with the OpenRouter metadata. GLM 5.2 lists `structured_outputs` as a supported parameter; **GLM 5.3 does not**.

The good news for MCP: _this does not affect tool calls_. Tool arguments go through a different path, and that path is solid.

So if you need guaranteed JSON shapes, route that step to GLM 5.2 and keep GLM 5.3 for the agent loop.

## Why GLM 5.3 Needs a Bigger Token Budget

My first test run made GLM 5.3 look worse than GLM 5.2. That was my fault, and it is worth explaining.

I had `max_tokens` set to 4,000 — fine for a normal model, far too tight for a reasoning one.

GLM 5.3 spent that budget thinking, then got cut off **mid tool call**. The result was unparseable arguments and one missing call entirely.

Raising the ceiling to 16,000 fixed it completely. Same prompts, same server, 8/8.

**If GLM 5.3 seems to emit broken tool calls, check your token ceiling first.** It is almost always this.

The failure is nasty because `finish_reason` still reads `tool_calls`, not `length`. Nothing tells you it truncated.

## When to Use GLM 5.3 for MCP Servers

After the testing, here is where I would actually reach for it.

**Use GLM 5.3 when:**

-   Your tools have **deeply nested schemas** with enums and numeric bounds
-   A wrong write is expensive and you would rather wait 13 seconds than roll back
-   You are running long agent chains that need a big context window
-   You want frontier-ish argument accuracy at roughly a third of frontier pricing

**Skip it when:**

-   You need **structured JSON output** — use GLM 5.2 instead
-   Latency matters and your tools are simple — Haiku 4.5 was four times faster here
-   You are doing high-volume smoke tests where GLM 4.7 Flash is good enough

For a wider sweep across providers, the [best AI model for MCP tool calling](/blog/best-ai-model-for-mcp-tool-calling) comparison covers the rest of the field.

## How to Test Your MCP Server With GLM 5.3

You do not need the script I wrote. Four steps in the browser:

1.  Open [MCP Agent Studio](/mcp-agent-studio) and paste your server URL.
2.  Pick **GLM 5.3** from the model picker, under Z.AI.
3.  Send a prompt that should trigger your most complex tool.
4.  Open the tool-call inspector and read the arguments it actually sent.

That fourth step is the whole point. **Read the arguments, not just the answer.**

A model can produce a convincing reply off a half-wrong tool call. The inspector is where that shows up.

If your tool descriptions are vague, fix those before blaming the model — [tool description quality](/blog/mcp-tool-description-quality) moves accuracy more than model choice does.

And before you point any agent at a production server, [scan your MCP server](/mcp-security-scanner) for tool-poisoning and injection risks.

## How MCP Playground Helps

**MCP Playground is where I ran every model in this post.** It is browser-based and free to start.

Connect any MCP server, pick GLM 5.3 or any of 60+ models, and watch each tool call as it happens. No API key wrangling.

The compare view runs two models on the same prompt side by side — which is exactly how I caught the GLM 5.2 null-versus-optional bug.

## Frequently Asked Questions

**Is GLM 5.3 better than GLM 5.2 for MCP?** For tool calling, yes — 24/24 versus 20/24 on nested schemas across three runs. For structured JSON output, no. GLM 5.2 still wins there.

**Does GLM 5.3 support parallel tool calls?** In practice yes. It returned two tool calls in a single message when a prompt needed both, even though the parameter is not listed as supported.

**Why are my GLM 5.3 tool calls truncated?** Your `max_tokens` is too low. It is a reasoning model and spends tokens before emitting the call. Try 16,000.

**How much does GLM 5.3 cost?** $1.40 per 1M input tokens and $4.40 per 1M output, with cached input at $0.26. About 18% more than GLM 5.2.

## Conclusion

**GLM 5.3 is the most reliable GLM yet at filling nested MCP tool schemas.** It swept my test where 5.2 dropped one and 5.1 fell apart.

You pay for it in latency and output tokens, and you give up structured outputs entirely. Plan around both.

The only benchmark that matters is your own server. [Test any MCP server free](/mcp-test-server), then switch between GLM 5.3 and 5.2 mid-chat and read the arguments each one sends.

🔀 Comparing models for MCP?

MCP is model-agnostic — the protocol sits between the client and your server, not inside the model — but tool _selection_ is a judgement each model makes differently. [MCP with different AI models](/mcp-model-comparison) covers which families work, why the same server behaves differently per model, and what to measure.

Other guides in this series: [GLM family guide](/blog/test-mcp-server-with-glm-models), [DeepSeek V4](/blog/testing-mcp-with-deepseek), [Qwen](/blog/test-mcp-server-with-qwen-models), [Gemini](/blog/test-mcp-server-with-gemini-models), [Grok](/blog/testing-mcp-with-grok-xai), [Kimi K2.6](/blog/test-mcp-server-with-kimi-k2-6).

## Frequently asked questions

### Is GLM 5.3 better than GLM 5.2 for MCP tool calling?

For tool calling, yes. Across three runs of an eight-prompt test against a live MCP server with deeply nested schemas, GLM 5.3 produced schema-valid arguments on 24 of 24 calls and the server accepted all 24. GLM 5.2 managed 20 of 24, mostly by passing an object where the schema required a string. For structured JSON output the answer reverses — GLM 5.2 honours response_format with a JSON schema and GLM 5.3 does not.

### Why are my GLM 5.3 tool calls truncated or unparseable?

Your max_tokens ceiling is almost certainly too low. GLM 5.3 is a reasoning model and spends output tokens thinking before it emits the tool call. At max_tokens 4000 it was cut off mid-call, producing unparseable arguments while still reporting a finish_reason of tool_calls, so nothing signals the truncation. Raising the ceiling to 16000 resolved every failure.

### Does GLM 5.3 support structured outputs?

No. OpenRouter does not list structured_outputs among its supported parameters, and testing confirms it. Given a strict JSON schema three times, GLM 5.3 returned zero schema-valid responses — it wrapped output in markdown code fences and renamed fields. GLM 5.2 returned valid JSON on all three runs. Tool calling is unaffected, since tool arguments follow a different path.

### How much does GLM 5.3 cost compared to GLM 5.2?

GLM 5.3 costs $1.40 per 1M input tokens and $4.40 per 1M output tokens, with cached input at $0.26 per 1M. That is roughly 18 percent more than GLM 5.2 at $1.19 and $3.74. Because GLM 5.3 is a reasoning model it also emits far more output tokens for the same work — about 12,000 versus under 4,000 across eight tool calls in testing — so the real cost gap per task is wider than the headline rate.

### Does GLM 5.3 support parallel tool calls?

In practice yes. Given a prompt that required two different tools, GLM 5.3 returned both tool calls in a single assistant message, with and without the parallel_tool_calls parameter set. The parameter is not listed among its supported parameters on OpenRouter, so it appears to be ignored rather than honoured, but the underlying behaviour works.

### What context window does GLM 5.3 have?

GLM 5.3 has a 1,048,576-token context window, the same as GLM 5.2. Its maximum output is 131,072 tokens, which is half of GLM 5.2 at 262,144. For long agent chains the input window is rarely the constraint; the output ceiling matters more because reasoning tokens count against it.


---

_Canonical page: https://mcpplaygroundonline.com/blog/glm-5-3-mcp-servers — MCP Playground (mcpplaygroundonline.com), the free browser-based tool for testing MCP servers and building AI agents._