GLM 5.2: Reasoning Effort ist der Kostenhebel

GLM 5.2 ist jetzt auf Synthorai verfügbar, zu rund einem Sechstel des Token-Preises der Frontier-Modelle, und die Schlagzeile vom Open-Weight-Modell mit Frontier-Benchmarks stimmt tatsächlich. Aber der Token-Preis ist die falsche Zahl, an der man sich orientiert. Was ein Coding-Task auf GLM 5.2 wirklich kostet, schwankt um mehr als eine Größenordnung – abhängig von einem einzigen Regler: dem reasoning_effort. Und das Default lässt diesen Regler in der schlechtesten Stellung. Stellt man ihn richtig ein, liefert GLM 5.2 korrekte Ergebnisse und ist sowohl bei leichten als auch bei schweren Aufgaben billiger als die Frontier-Modelle. Lässt man das Default stehen, kostet dieselbe Antwort das Zwanzigfache und dauert Minuten. Wir haben es gemessen.

Was GLM 5.2 ist

GLM 5.2 ist Zhipus Open-Weight-Frontier-Modell, veröffentlicht am 13.06.2026: ein Mixture-of-Experts-Netz (~744B gesamt, ~40B aktiv), ein nutzbarer Kontext von 1M Token und eine MIT-Lizenz, sodass du es selbst hosten kannst. Es ist auf Coding und agentische Arbeit ausgelegt und hat starke veröffentlichte Benchmarks (SWE-bench Pro 62.1, Terminal-Bench 2.1 81.0, AIME 2026 99.2, GPQA Diamond 91.2). Auf Synthorai heißt es glm-5.2 und kostet 1,40 $ pro Million Input-Token und 4,40 $ pro Million Output-Token.

Das Detail, das alles Folgende bestimmt: Es ist ein Reasoning-Modell, und wie viel es reasont, stellst du selbst ein.

Wo es preislich liegt

Beim Token-Listenpreis liegt GLM 5.2 deutlich unter der westlichen Frontier und unter den günstigeren chinesischen Modellen. Die Synthorai-Preise für eine repräsentative Auswahl:

Sein Output-Preis von 4,40 $ liegt bei etwa einem Siebtel von gpt-5.5 und einem Sechstel von claude-opus-4-8, auch wenn deepseek-v4-pro und kimi-k2.5 es unterbieten. GLM 5.2 bietet also Frontier-Niveau zu ungefähr chinesischen Modellpreisen – aber nicht zum absoluten Tiefstpreis. Eine separate Gebühr für Cache-Writes gibt es nicht: Ein Cache-Write wird zum Input-Preis abgerechnet, und nur der Cache-Read ist auf den oben genannten Preis rabattiert. Der Rabatt unterscheidet sich je nach Anbieter: Bei GLM 5.2 liegt der Cache-Read bei etwa einem Fünftel des Input-Preises, bei den Frontier-Modellen (gpt-5.5, claude-opus-4-8, gemini-3.1-pro) sind die Reads auf rund ein Zehntel rabattiert.

Es ist außerdem ein Schritt nach oben gegenüber den eigenen Vorgängern. Die vorige GLM-Generation war extrem günstig; die GLM-5-Reihe hat die Preise angehoben, und GLM 5.2 landet bei etwa dem 3-fachen Input-Preis von GLM-4.6 (offizielle Zhipu-Preise):

Dafür bekommst du den 1M-Kontext und die Frontier-Benchmarks. Aber der Token-Preis ist nur die Schlagzeile. Was du tatsächlich pro Task zahlst, bestimmt der reasoning_effort.

Der reasoning_effort-Regler

Das Reasoning von GLM 5.2 ist ein Regler, kein Schalter. Du kannst es abschalten (enable_thinking: false), reasoning_effort auf low, medium oder high setzen oder das Default stehen lassen, das das Reasoning unbegrenzt laufen lässt. Diese Einstellung verändert Kosten und Latenz weit stärker als der Preis. Wir haben je einen leichten und einen schweren Coding-Task über alle Einstellungen hinweg laufen lassen und jede Antwort an einer Referenz mit hunderten zufällig erzeugten Fällen geprüft.

Eine einfache Aufgabe: Reasoning kostet hier nur Geld

Weighted Interval Scheduling, ein mittelschweres Dynamic-Programming-Problem:

Zwei Dinge fallen auf. Mit abgeschaltetem Thinking ist die Antwort korrekt und zugleich die günstigste in der ganzen Tabelle — etwa 8x billiger als die Frontier-Modelle. Jede Stufe höher am Regler bringt nur mehr Kosten für dieselbe Antwort. Und die Rechnung hängt am Reasoning, nicht an der Antwort: Der Code, den GLM zurückgibt, hat jedes Mal rund 150 Token, während das vorgeschaltete Reasoning von null auf etwa 6.300 wächst — abgerechnet zum selben Output-Tarif von $4.40/M. Der Default ohne Limit verbrennt dieses Reasoning, um genau die Antwort zu erreichen, die Thinking aus ganz ohne Reasoning produziert hat. Dieser Unterschied macht die komplette Kostendifferenz aus. Die Frontier-Modelle beantworten die Aufgabe hier mit wenig oder gar keinem ausgewiesenen Reasoning: gpt-5.5 verbraucht 59 Reasoning-Token, und bei claude-opus-4-8 weist die Nutzung gar keine aus.

Eine schwere Aufgabe: Reasoning rechnet sich, der Default nicht

Wildcard-String-Matching (? und *) – ein Klassiker, bei dem man leicht subtile Fehler macht. Hier ist „thinking off” gescheitert. Es lieferte eine memoisierte Rekursion zurück:

def is_match(s, p):
    memo = {}
    def match(i, j):
        if (i, j) in memo:
            return memo[(i, j)]
        if j == len(p):
            result = i == len(s)
        elif i < len(s) and p[j] in (s[i], '?'):
            result = match(i + 1, j + 1)
        elif p[j] == '*':
            result = match(i + 1, j) or match(i, j + 1)
        else:
            result = False
        memo[(i, j)] = result
        return result
    return match(0, 0)

Sieht richtig aus, und das Memo deutet sogar auf etwas Sorgfalt hin. Aber der *-Zweig ruft match(i + 1, j) auf, ohne i zu begrenzen. Sobald der String aufgebraucht ist und das Pattern noch ein * enthält, klettert i endlos weiter und der Stack läuft über. Schnell, billig und falsch.

Dreht man den Regler hoch, kommt der korrekte iterative Two-Pointer-Algorithmus zurück, der zum letzten * zurückspringt, statt zu rekursieren:

def is_match(s, p):
    s_idx, p_idx, star_idx, match_idx = 0, 0, -1, 0
    while s_idx < len(s):
        if p_idx < len(p) and (p[p_idx] == '?' or p[p_idx] == s[s_idx]):
            s_idx += 1
            p_idx += 1
        elif p_idx < len(p) and p[p_idx] == '*':
            star_idx = p_idx
            match_idx = s_idx
            p_idx += 1
        elif star_idx != -1:
            p_idx = star_idx + 1
            match_idx += 1
            s_idx = match_idx
        else:
            return False
    while p_idx < len(p) and p[p_idx] == '*':
        p_idx += 1
    return p_idx == len(p)

Der komplette Reglerbereich bei dieser Aufgabe:

Jede explizite Effort-Stufe hat die Aufgabe gelöst. reasoning_effort: high schaffte es für $0.0031 in 13 Sekunden – etwa zwanzigmal billiger und dreißigmal schneller als der unbounded default bei identischem Ergebnis. Und es unterbietet die Frontier-Modelle bei den Kosten, nur ein paar Sekunden langsamer. Eine Eigenheit, die man kennen sollte: GLMs low produzierte mehr Reasoning als high, und das bei beiden Aufgaben konsistent. Die Namen korrelieren also nicht mit der Token-Zahl. Medium und high waren die billigen, schnellen Einstellungen.

Den unbounded default sollte man als einzige Einstellung meiden. Er vereint das Schlechteste aus beiden Welten: Er kauft Reasoning, das die Aufgabe womöglich gar nicht braucht, und braucht dafür Minuten – um beim selben Ergebnis zu landen, das reasoning_effort: high zum zwanzigfach niedrigeren Preis lieferte.

Die Entscheidungsregel

Der Hebel ist der Reasoning-Effort, und die richtige Einstellung gehört zur Aufgabe, nicht zum Modell:

• Einfache oder volumenstarke Arbeit, bei der Korrektheit leichtfällt: thinking off (enable_thinking: false). Korrekt und etwa 8x unter Frontier.
• Schwierigere Probleme, bei denen thinking off scheitert: reasoning_effort: medium oder high. Korrekt, rund $0.003 pro Aufgabe, kostenseitig unter Frontier und nur ein paar Sekunden langsamer.
• Niemals der unbounded default. Reasoning ohne Effort-Limit anzulassen ist der Weg, aus einer $0.003-Antwort eine $0.06-Antwort von sieben Minuten zu machen.

Wenn man vorab nicht beurteilen kann, ob eine Aufgabe Reasoning braucht, ist reasoning_effort: high ein sicherer Default: günstig, hat beide Aufgaben gelöst und ist nie aus dem Ruder gelaufen.

Caching hilft beim Input, nicht beim Reasoning

GLM 5.2 unterstützt Caching auf dem Gateway, und es hilft genau dort, wo man es erwartet. Wir haben ein gemeinsames Prefix von 1.494 Tokens (ein Code-Modul zum Review) mit mehreren verschiedenen Fragen geschickt:

Sobald ein großes Prefix einmal gesehen wurde, landet es im Cache. Die gecachten Input-Tokens werden mit ungefähr einem Fünftel des normalen Input-Tarifs abgerechnet, was einen ansonsten identischen Request von $0.0026 auf $0.0009 senkte – etwa 64%. Eine exakte Wiederholung kommt direkt aus dem semantischen Cache: dieselbe Antwort zu denselben Kosten wie der gecachte Call, aber in rund einer Sekunde statt fünf.

Der Haken ist derselbe, den uns schon der Drehregler beigebracht hat: Caching gibt Rabatt auf den Input, und sobald Reasoning aktiv ist, stecken Kosten und Latenz im Reasoning-Output – und der wird nicht gecacht. Caching ist also ein echter Gewinn bei Workloads ohne Thinking und mit viel Kontext (derselbe System-Prompt oder dieselbe Codebase bei jedem Call) und nur ein kleiner, sobald Reasoning eingeschaltet ist.

Einsatz auf Synthorai

glm-5.2 ist auf dem Gateway live. Drei praktische Hinweise aus unseren Tests:

• Setze den Reasoning-Aufwand explizit. Nutze enable_thinking: false für einfache Aufgaben und reasoning_effort: medium oder high für schwierigere Probleme. Was man unbedingt vermeiden sollte: Reasoning eingeschaltet lassen, ohne Effort-Cap (der unbegrenzte Default) – das ist die $0.06-und-sieben-Minuten-Falle.
• Bei aktivem Reasoning streamen. Reasoning-Antworten können minutenlang laufen, und ein Non-Streaming-Request hängt so lange auf einer stillen Verbindung, dass dein Client wahrscheinlich in den Timeout läuft, bevor die Antwort da ist. Mit stream: true bekommst du inkrementellen Output und das vollständige Ergebnis.
• Kontext wiederverwenden. Wenn du bei jedem Call denselben großen System-Prompt oder dieselbe Codebase schickst, senkt Prefix-Caching die Input-Kosten – und in Kombination mit ausgeschaltetem Thinking wird der ganze Request günstig.

Die Preise liegen bei $1.40 / $4.40 pro Million Tokens, und das Gateway liefert pro Call ein cost-Feld zurück, sodass du genau siehst, was jeder Request gekostet hat.

Fazit

GLM 5.2 ist ein wirklich günstiges, leistungsfähiges Coding-Modell, und richtig konfiguriert schlägt es bei einfachen wie bei schweren Aufgaben die Preise der Frontier-Modelle. Der Haken ist die Konfiguration. Sein Reasoning ist ein Drehregler, und der Default lässt ihn unbegrenzt laufen – so wird aus einer Aufgabe, die $0.003 kosten sollte, ein Call für $0.06 und sieben Minuten. Setze enable_thinking: false für einfache Aufgaben und reasoning_effort: medium oder high für den Rest, dann ist GLM 5.2 durchgängig günstig und korrekt. Lässt du Reasoning auf dem Default, ist es die langsamste und teuerste Option, die du hättest wählen können.

Quellen

• VentureBeat: Z.ai’s open-weight GLM-5.2 beats GPT-5.5 on long-horizon coding for 1/6 the cost
• eigent.ai: GLM-5.2 specs and overview
• CloudPrice: GLM-5.2 pricing and specs
• Z.ai: official GLM API pricing (GLM-4.5 / 4.6 / 5 generations)

(Die oben genannten Synthorai-Listenpreise sind die Tarife dieser Plattform mit Stand 2026-06-24; die GLM-Generationspreise sind Zhipus offizielle Liste.)

Kosten gemessen auf Synthorai am 2026-06-24 (glm-5.2 zu $1.40 / $4.40 pro M Tokens); prüfe die aktuellen Preise, bevor du dich darauf verlässt.

← Zurück zum Blog