GLM-5: Leitfaden zum lokalen Ausführen

Führe das neue GLM-5-Modell von Z.ai auf deinem eigenen lokalen Gerät aus!

GLM-5 ist Z.ais neuestes Reasoning-Modell und liefert stärkere Leistungen beim Coden, bei Agenten und im Chat als GLM-4.7, und ist für Long-Context-Reasoning konzipiert. Es steigert die Leistung bei Benchmarks wie Humanity's Last Exam auf 50,4 % (+7,6 %), BrowseComp auf 75,9 % (+8,4 %) und Terminal-Bench-2.0 auf 61,1 % (+28,3 %).

Das vollständige Modell mit 744B Parametern (40B aktiv) hat ein 200K-Kontext Fenster und wurde auf 28,5T Tokens vortrainiert. Das vollständige GLM-5-Modell benötigt 1,65 TB Festplattenspeicher, während das Unsloth Dynamic 2-Bit GGUF die Größe reduziert auf 241 GB (-85%), und dynamisch 1-Bit sind es 176 GB (-89 %): GLM-5-GGUF

Alle Uploads verwenden Unsloth Dynamic 2.0 für Spitzenleistung bei der Quantisierung – daher werden bei 1-Bit wichtige Layer auf 8- oder 16-Bit hochgestuft. Vielen Dank an Z.ai für den Day-Zero-Zugriff auf Unsloth.

⚙️ Nutzungsanleitung

Die dynamische 2-Bit-Quantisierung UD-IQ2_XXS verwendet 241 GB an Festplattenspeicher – das passt direkt auf einen Mac mit 256 GB Unified Memory, und funktioniert auch gut in einer 1x24-GB-Karte und 256 GB RAM mit MoE-Offloading. Das 1-Bit Quant passt in 180 GB RAM, und 8-Bit benötigt 805 GB RAM.

Für die beste Leistung stellen Sie sicher, dass Ihr insgesamt verfügbarer Speicher (VRAM + Systemspeicher) größer ist als die Größe der quantisierten Modelldatei, die Sie herunterladen. Falls nicht, kann llama.cpp weiterhin per SSD/HDD-Offloading laufen, aber die Inferenz wird langsamer sein.

Empfohlene Einstellungen

Verwenden Sie unterschiedliche Einstellungen für verschiedene Anwendungsfälle:

Standardeinstellungen (die meisten Aufgaben)	SWE Bench Verified
temperature = 1.0	temperature = 0.7
top_p = 0.95	top_p = 1.0
max. neue Token = 131072	max. neue Token = 16384
Wiederholungsstrafe = deaktiviert oder 1,0	Wiederholungsstrafe = deaktiviert oder 1,0

• Min_P = 0.01 (Der Standardwert von llama.cpp ist 0.05)

• Maximales Kontextfenster: 202,752.

• Für mehrstufige agentische Aufgaben (τ²-Bench und Terminal Bench 2) schalten Sie bitte den Preserved Thinking-Modus ein.

GLM-5-Tutorials ausführen:

✨ In llama.cpp ausführen

1

Holen Sie sich die neueste llama.cpp auf GitHub hier. Sie können auch die Build-Anweisungen unten befolgen. Ändern Sie -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn Sie keine GPU haben oder nur CPU-Inferenz möchten. Für Apple-Mac-/Metal-Geräte, setzen Sie -DGGML_CUDA=OFF und fahren Sie dann wie gewohnt fort – Metal-Unterstützung ist standardmäßig aktiviert.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \\
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

2

Wenn Sie llama.cpp direkt zum Laden von Modellen verwenden möchten, können Sie Folgendes tun: (:IQ2_XXS) ist der Quantisierungstyp. Sie können auch über Hugging Face (Punkt 3) herunterladen. Das ist ähnlich wie ollama run . Verwenden Sie export LLAMA_CACHE="folder" um zu erzwingen, llama.cpp dass es an einem bestimmten Ort gespeichert wird. Denken Sie daran, dass das Modell nur eine maximale Kontextlänge von 200K hat.

Befolgen Sie dies für allgemeine Anweisungen Anwendungsfälle:

export LLAMA_CACHE="unsloth/GLM-5-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/GLM-5-GGUF:UD-IQ2_XXS \\
    --ctx-size 16384 \\
    --flash-attn on \\
    --temp 0.7 \\
    --top-p 1.0 \\
    --min-p 0.01

Befolgen Sie dies für Tool-Aufrufe Anwendungsfälle:

export LLAMA_CACHE="unsloth/GLM-5-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/GLM-5-GGUF:UD-IQ2_XXS \\
    --ctx-size 16384 \\
    --flash-attn on \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --min-p 0.01

3

Laden Sie das Modell über Folgendes herunter (nach der Installation von pip install huggingface_hub hf_transfer ). Sie können wählen UD-Q2_K_XL (dynamische 2-Bit-Quantisierung) oder andere quantisierte Versionen wie UD-Q4_K_XL . Wir empfehlen, unsere dynamische 2-Bit-Quantisierung zu verwenden, UD-Q2_K_XL um Größe und Genauigkeit auszubalancieren. Wenn Downloads hängen bleiben, siehe Hugging Face Hub, XET-Debugging

pip install -U huggingface_hub
hf download unsloth/GLM-5-GGUF \\
    --local-dir unsloth/GLM-5-GGUF \\
    --include "*UD-IQ2_XXS*" # Verwenden Sie "*UD-TQ1_0*" für Dynamic 1-Bit

4

Sie können --threads 32 für die Anzahl der CPU-Threads, --ctx-size 16384 für die Kontextlänge, --n-gpu-layers 2 für GPU-Offloading, wie viele Layer ausgelagert werden. Versuchen Sie, diesen Wert anzupassen, wenn Ihrem GPU der Speicher ausgeht. Entfernen Sie ihn außerdem, wenn Sie nur CPU-Inferenz haben.

./llama.cpp/llama-cli \\
    --model unsloth/GLM-5-GGUF/UD-IQ2_XXS/GLM-5-UD-IQ2_XXS-00001-of-00006.gguf \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --min-p 0.01 \\
    --ctx-size 16384 \\
    --seed 3407

🦙 Llama-Server-Serving & OpenAIs Completion-Bibliothek

Um GLM-5 für den produktiven Einsatz bereitzustellen, verwenden wir llama-server In einem neuen Terminal, z. B. über tmux, stellen Sie das Modell wie folgt bereit:

./llama.cpp/llama-server \\
    --model unsloth/GLM-5-GGUF/UD-IQ2_XXS/GLM-5-UD-IQ2_XXS-00001-of-00006.gguf \\
    --alias "unsloth/GLM-5" \\
    --prio 3 \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --ctx-size 16384 \\
    --port 8001

Dann führen Sie in einem neuen Terminal nach pip install openaiFolgendes aus:

from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/GLM-5",
    messages = [{"role": "user", "content": "Erstelle ein Snake-Spiel."},],
)
print(completion.choices[0].message.content)

Und Sie erhalten das folgende Beispiel eines Snake-Spiels:

Hier ist ein vollständiges, spielbares Snake-Spiel, das in einer einzigen HTML-Datei enthalten ist. Sie können diesen Code kopieren, als `.html`-Datei speichern (z. B. `snake.html`) und in Ihrem Webbrowser öffnen, um zu spielen.

### Der Code

```html
<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Klassisches Snake-Spiel</title>
    <style>
        body {
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
            background-color: #222;
            color: white;
            font-family: Arial, sans-serif;
        }

        #gameCanvas {
            border: 2px solid #fff;
            background-color: #000;
        }

        h1 {
            margin-bottom: 10px;
        }

        #scoreBoard {
            font-size: 20px;
            margin-bottom: 10px;
        }

        #gameOverMenu {
            position: absolute;
            display: none;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            background: rgba(0, 0, 0, 0.85);
            padding: 20px;
            border-radius: 10px;
            border: 2px solid red;
        }

        button {
            margin-top: 15px;
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
            background-color: #4CAF50;
            color: white;
            border: none;
            border-radius: 5px;
        }
        
        button:hover {
            background-color: #45a049;
        }
    </style>
</head>
<body>

    <h1>Snake-Spiel</h1>
    <div id="scoreBoard">Punktzahl: 0</div>
    <canvas id="gameCanvas" width="400" height="400"></canvas>

    <div id="gameOverMenu">
        <h2 style="color: red; margin: 0;">Spiel beendet!</h2>
        <p id="finalScore">Endpunktzahl: 0</p>
        <button onclick="resetGame()">Nochmal spielen</button>
    </div>

    <script>
        // Spielkonstanten
        const canvas = document.getElementById('gameCanvas');
        const ctx = canvas.getContext('2d');
        const scoreBoard = document.getElementById('scoreBoard');
        const gameOverMenu = document.getElementById('gameOverMenu');
        const finalScoreDisplay = document.getElementById('finalScore');

        const gridSize = 20; // Größe jedes Quadrats
        const tileCount = canvas.width / gridSize; // Anzahl der Quadrate pro Reihe/Spalte

        // Spielvariablen
        let dx = 0; // Horizontale Geschwindigkeit
        let dy = 0; // Vertikale Geschwindigkeit
        let score = 0;
        let snake = [];
        let foodX, foodY;
        let gameInterval;
        let isGameRunning = false;

        // Spiel initialisieren
        function initGame() {
            snake = [
                {x: 10, y: 10}, 
                {x: 9, y: 10}, 
                {x: 8, y: 10}
            ];
            score = 0;
            scoreBoard.innerText = 'Punktzahl: ' + score;
            dx = 1; // Sofort nach rechts starten
            dy = 0;
            placeFood();
            isGameRunning = true;
            gameOverMenu.style.display = 'none';
            
            // Spielschleife starten
            if (gameInterval) clearInterval(gameInterval);
            gameInterval = setInterval(gameLoop, 100); // Spielschleife alle 100 ms ausführen
        }

        // Hauptspielschleife
        function gameLoop() {
            if (!isGameRunning) return;

            moveSnake();
            if (checkGameOver()) {
                endGame();
                return;
            }
            checkFoodCollision();
            draw();
        }

        // Die Schlange bewegen
        function moveSnake() {
            // Neuen Kopf basierend auf der aktuellen Richtung erstellen
            const head = {x: snake[0].x + dx, y: snake[0].y + dy};
            
            // Neuen Kopf am Anfang des Arrays hinzufügen
            snake.unshift(head);

            // Den Schwanz (letztes Element) entfernen, sofern kein Futter gefressen wurde
            // Hinweis: Das Entfernen des Schwanzes wird in checkFoodCollision behandelt
            snake.pop(); 
        }

        // Prüfen, ob die Schlange Futter frisst
        function checkFoodCollision() {
            const head = snake[0];
            
            if (head.x === foodX && head.y === foodY) {
                // Schlange wachsen lassen: ein Schwanzstück hinzufügen (das letzte duplizieren)
                snake.push({...snake[snake.length - 1]});
                score += 10;
                scoreBoard.innerText = 'Punktzahl: ' + score;
                placeFood();
            }
        }

        // Auf Kollisionen prüfen (Wände oder sich selbst)
        function checkGameOver() {
            const head = snake[0];

            // Wandkollision
            if (head.x < 0 || head.x >= tileCount || head.y < 0 || head.y >= tileCount) {
                return true;
            }

            // Selbstkollision (mit der Prüfung ab dem 4. Segment beginnen, da der Kopf die ersten 3 nicht treffen kann)
            for (let i = 4; i < snake.length; i++) {
                if (head.x === snake[i].x && head.y === snake[i].y) {
                    return true;
                }
            }

            return false;
        }

        // Alles zeichnen
        function draw() {
            // Canvas leeren
            ctx.fillStyle = 'black';
            ctx.fillRect(0, 0, canvas.width, canvas.height);

            // Futter zeichnen
            ctx.fillStyle = 'red';
            ctx.fillRect(foodX * gridSize, foodY * gridSize, gridSize - 2, gridSize - 2);

            // Schlange zeichnen
            ctx.fillStyle = 'lime';
            for (let i = 0; i < snake.length; i++) {
                // Den Kopf leicht anders oder einfach standardmäßig zeichnen
                const part = snake[i];
                ctx.fillRect(part.x * gridSize, part.y * gridSize, gridSize - 2, gridSize - 2);
            }
        }

        // Futter an einer zufälligen Position platzieren
        function placeFood() {
            foodX = Math.floor(Math.random() * tileCount);
            foodY = Math.floor(Math.random() * tileCount);

            // Sicherstellen, dass das Futter nicht auf dem Schlangenkörper erscheint
            for (let part of snake) {
                if (part.x === foodX && part.y === foodY) {
                    placeFood(); // Rekursiv einen neuen Platz finden
                    return;
                }
            }
        }

        // Logik zum Spielende
        function endGame() {
            isGameRunning = false;
            clearInterval(gameInterval);
            finalScoreDisplay.innerText = 'Endpunktzahl: ' + score;
            gameOverMenu.style.display = 'flex';
        }

        // Spiel-Reset-Logik
        function resetGame() {
            initGame();
        }

        // Tastatursteuerung
        document.addEventListener('keydown', (e) => {
            // Verhindern, dass die Richtung umgekehrt wird (man kann nicht nach links, wenn man nach rechts fährt)
            switch(e.key) {
                case 'ArrowUp':
                    if (dy !== 1) { dx = 0; dy = -1; }
                    break;
                case 'ArrowDown':
                    if (dy !== -1) { dx = 0; dy = 1; }
                    break;
                case 'ArrowLeft':
                    if (dx !== 1) { dx = -1; dy = 0; }
                    break;
                case 'ArrowRight':
                    if (dx !== -1) { dx = 1; dy = 0; }
                    break;
                case ' ':
                    if (!isGameRunning && gameOverMenu.style.display !== 'flex') {
                        initGame();
                    }
                    break;
            }
        });

        // Das Spiel beim Laden starten
        initGame();
    </script>
</body>
</html>
```

### So spielt man
1.  **Kopieren Sie den Code** oben.
2.  Erstellen Sie auf Ihrem Computer eine neue Datei mit dem Namen `snake.html`.
3.  **Fügen Sie den Code** in diese Datei ein und speichern Sie sie.
4.  **Doppelklicken Sie auf `snake.html`**, um sie in Ihrem Browser zu öffnen.

### Steuerung
*   **Pfeiltasten**: Nach oben, unten, links, rechts bewegen.
*   **Leertaste**: Startet das Spiel (falls es noch nicht gestartet wurde).
*   **Taste „Erneut spielen“**: Erscheint, wenn Sie verlieren, um das Spiel neu zu starten.

### Funktionen dieser Version
*   **Rasterbasiertes Bewegen**: Klassisches Retrogefühl.
*   **Punktestandverfolgung**: Wird in Echtzeit aktualisiert.
*   **Game-Over-Bildschirm**: Zeigt Ihren Endstand an und ermöglicht Ihnen einen einfachen Neustart.
*   **Kollisionserkennung**: Beendet das Spiel, wenn Sie gegen die Wände oder sich selbst stoßen.
*   **Schutz vor Selbstkollision**: Der Code verhindert, dass die Schlange sich unmittelbar nach dem Fressen von Nahrung versehentlich selbst frisst, aufgrund der "Tail-Skipping"-Logik, die in einfachen Tutorials häufig vorkommt.

💻 vLLM-Bereitstellung

Sie können jetzt Z.ai's FP8-Version des Modells über vLLM bereitstellen. Sie benötigen 860 GB VRAM oder mehr, daher werden mindestens 8xH200 (141x8 = 1128 GB) empfohlen. 8xB200 funktioniert gut. Installieren Sie zunächst die Nightly-Version von vllm:

uv pip install --upgrade --force-reinstall vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly/cu130
uv pip install --upgrade --force-reinstall git+https://github.com/huggingface/transformers.git
uv pip install --force-reinstall numba

Um den FP8-KV-Cache zu deaktivieren (reduziert den Speicherverbrauch um 50 %), entfernen Sie --kv-cache-dtype fp8

export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:False
vllm serve unsloth/GLM-5-FP8 \\
    --served-model-name unsloth/GLM-5-FP8 \\
    --kv-cache-dtype fp8 \\
    --tensor-parallel-size 8 \\
    --tool-call-parser glm47 \\
    --reasoning-parser glm45 \\
    --enable-auto-tool-choice \\
    --dtype bfloat16 \\
    --seed 3407 \\
    --max-model-len 200000 \\
    --gpu-memory-utilization 0.93 \\
    --max_num_batched_tokens 4096 \\
    --speculative-config.method mtp \\
    --speculative-config.num_speculative_tokens 1 \\
    --port 8001

Anschließend können Sie das bereitgestellte Modell über die OpenAI-API aufrufen:

from openai import AsyncOpenAI, OpenAI
openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8001/v1"
client = OpenAI( # or AsyncOpenAI
    api_key = openai_api_key,
    base_url = openai_api_base,
)

🔨Tool-Calling mit GLM 5

Siehe Tool Calling Guide für weitere Details zum Tool-Calling. In einem neuen Terminal (wenn Sie tmux verwenden, drücken Sie CTRL+B+D) erstellen wir einige Tools wie das Hinzufügen von 2 Zahlen, das Ausführen von Python-Code, das Ausführen von Linux-Funktionen und vieles mehr:

import json, subprocess, random
from typing import Any
def add_number(a: float | str, b: float | str) -> float:
    return float(a) + float(b)
def multiply_number(a: float | str, b: float | str) -> float:
    return float(a) * float(b)
def subtract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "Vor langer, langer Zeit in einer weit, weit entfernten Galaxis...",
        "Es gab 2 Freunde, die Faultiere und Code liebten...",
        "Die Welt ging unter, weil sich jedes Faultier zu übermenschlicher Intelligenz entwickelt hatte...",
        "Ohne dass es ein Freund wusste, hatte der andere versehentlich ein Programm geschrieben, um Faultiere weiterzuentwickeln...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Kann die Befehle 'rm, sudo, dd, chmod' nicht ausführen, da sie gefährlich sind"
        print(msg); return msg
    print(f"Führe Terminalbefehl `{command}` aus")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"Befehl fehlgeschlagen: {e.stderr}"
def python(code: str) -> str:
    data = {}
    exec(code, data)
    del data["__builtins__"]
    return str(data)
MAP_FN = {
    "add_number": add_number,
    "multiply_number": multiply_number,
    "subtract_number": subtract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "Addiere zwei Zahlen.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Die erste Zahl.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Die zweite Zahl.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "Multipliziert zwei Zahlen.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Die erste Zahl.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Die zweite Zahl.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "subtract_number",
            "description": "Subtrahiert zwei Zahlen.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Die erste Zahl.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Die zweite Zahl.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_a_story",
            "description": "Schreibt eine zufällige Geschichte.",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "Führt Operationen im Terminal aus.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "Der Befehl, den Sie ausführen möchten, z. B. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Ruft einen Python-Interpreter mit etwas Python-Code auf, der ausgeführt wird.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "Der auszuführende Python-Code",
                    },
                },
                "required": ["code"],
            },
        },
    },
]

Anschließend verwenden wir die untenstehenden Funktionen (kopieren, einfügen und ausführen), die die Funktionsaufrufe automatisch parsen und den OpenAI-Endpunkt für jedes Modell aufrufen:

from openai import OpenAI
def unsloth_inference(
    messages,
    temperature = 1.0,
    top_p = 0.95,
    top_k = -1,
    min_p = 0.01,
    repetition_penalty = 1.0,
):
    messages = messages.copy()
    openai_client = OpenAI(
        base_url = "http://127.0.0.1:8001/v1",
        api_key = "sk-no-key-required",
    )
    model_name = next(iter(openai_client.models.list())).id
    print(f"Verwende Modell = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Aktuelle Nachrichten = {messages}")
        response = openai_client.chat.completions.create(
            model = model_name,
            messages = messages,
            temperature = temperature,
            top_p = top_p,
            tools = tools if tools else None,
            tool_choice = "auto" if tools else None,
            extra_body = {"top_k": top_k, "min_p": min_p, "repetition_penalty" :repetition_penalty,}
        )
        tool_calls = response.choices[0].message.tool_calls or []
        content = response.choices[0].message.content or ""
        tool_calls_dict = [tc.to_dict() for tc in tool_calls] if tool_calls else tool_calls
        messages.append({"role": "assistant", "tool_calls": tool_calls_dict, "content": content,})
        for tool_call in tool_calls:
            fx, args, _id = tool_call.function.name, tool_call.function.arguments, tool_call.id
            out = MAP_FN[fx](**json.loads(args))
            messages.append({"role": "tool", "tool_call_id": _id, "name": fx, "content": str(out),})
        else:
            has_tool_calls = False
    return messages

Nach dem Start von GLM 5 über llama-server wie in GLM-5 oder siehe Tool Calling Guide für weitere Details können wir dann einige Tool-Calls durchführen.

📊 Benchmarks

Weiter unten können Sie die Benchmarks in Tabellenform sehen:

Benchmark	GLM-5	GLM-4.7	DeepSeek-V3.2	Kimi K2.5	Claude Opus 4.5	Gemini 3 Pro	GPT-5.2 (xhigh)
HLE	30.5	24.8	25.1	31.5	28.4	37.2	35.4
HLE (mit Tools)	50.4	42.8	40.8	51.8	43.4*	45.8*	45.5*
AIME 2026 I	92.7	92.9	92.7	92.5	93.3	90.6	-
HMMT Nov. 2025	96.9	93.5	90.2	91.1	91.7	93.0	97.1
IMOAnswerBench	82.5	82.0	78.3	81.8	78.5	83.3	86.3
GPQA-Diamond	86.0	85.7	82.4	87.6	87.0	91.9	92.4
SWE-bench Verified	77.8	73.8	73.1	76.8	80.9	76.2	80.0
SWE-bench Multilingual	73.3	66.7	70.2	73.0	77.5	65.0	72.0
Terminal-Bench 2.0 (Terminus 2)	56.2 / 60.7 †	41.0	39.3	50.8	59.3	54.2	54.0
Terminal-Bench 2.0 (Claude Code)	56.2 / 61.1 †	32.8	46.4	-	57.9	-	-
CyberGym	43.2	23.5	17.3	41.3	50.6	39.9	-
BrowseComp	62.0	52.0	51.4	60.6	37.0	37.8	-
BrowseComp (mit Kontextverwaltung)	75.9	67.5	67.6	74.9	67.8	59.2	65.8
BrowseComp-Zh	72.7	66.6	65.0	62.3	62.4	66.8	76.1
τ²-Bench	89.7	87.4	85.3	80.2	91.6	90.7	85.5
MCP-Atlas (öffentliches Set)	67.8	52.0	62.2	63.8	65.2	66.6	68.0
Tool-Decathlon	38.0	23.8	35.2	27.8	43.5	36.4	46.3
Vending Bench 2	$4,432.12	$2,376.82	$1,034.00	$1,198.46	$4,967.06	$5,478.16	$3,591.33