GLM-5: Anleitung zum lokalen Betrieb

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 Codier-, Agenten- und Chat-Leistung als GLM-4.7und ist für Reasoning über lange Kontexte ausgelegt. Es steigert die Leistung in 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 744B-Parameter-Modell (40B aktiv) hat ein 200K-Kontext Fenster und wurde auf 28,5T Token vortrainiert. Das komplette GLM-5-Modell benötigt 1,65TB Festplattenspeicher, während das Unsloth Dynamic 2-bit GGUF die Größe auf 241GB (-85%)und dynamisches 1-Bit sind 176GB (-89%): GLM-5-GGUF

Alle Uploads verwenden Unsloth Dynamic 2.0 für SOTA-Quantisierungsleistung – daher werden bei 1-Bit wichtige Schichten auf 8- oder 16-Bit hochgestuft. Danke an Z.ai, dass sie Unsloth Tages-Null-Zugang gewährt haben.

⚙️ Nutzungsanleitung

Die 2-Bit-dynamische Quantisierung UD-IQ2_XXS verwendet 241GB an Festplattenspeicher – das passt direkt auf ein 256GB Unified-Memory Macund funktioniert auch gut in einem 1x24GB-Karte und 256GB RAM mit MoE-Offloading. Die 1-Bit Quantisierung passt in 180GB RAM und 8-Bit benötigt 805GB RAM.

Obwohl es nicht zwingend erforderlich ist, sollten Sie für die beste Leistung dafür sorgen, dass VRAM + RAM zusammen der Größe des Quant entsprechen, das Sie herunterladen. Falls nicht, funktioniert Festplatten-/SSD-Offloading mit llama.cpp, nur die Inferenz wird langsamer. Verwenden Sie außerdem --fit on in llama.cpp um die maximale GPU-Nutzung automatisch zu aktivieren!

Empfohlene Einstellungen

Verwende unterschiedliche Einstellungen für verschiedene Anwendungsfälle:

Standardeinstellungen (die meisten Aufgaben)	SWE Bench Verifiziert
temperature = 1.0	temperature = 0.7
top_p = 0.95	top_p = 1.0
max neue Tokens = 131072	max neue Tokens = 16384
repeat penalty = deaktiviert oder 1.0	repeat penalty = deaktiviert oder 1.0

• Min_P = 0.01 (llama.cpps Standard ist 0.05)

• Maximales Kontextfenster: 202,752.

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

Führe GLM-5 Tutorials aus:

✨ In llama.cpp ausführen

1

Holen Sie sich die neueste llama.cpp auf GitHub hier. Sie können auch den unten stehenden Build-Anweisungen folgen. Ändern Sie -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn Sie keine GPU haben oder nur CPU-Inferenz wünschen.

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 kannst du Folgendes tun: (:IQ2_XXS) ist der Quantisierungstyp. Du kannst auch über Hugging Face herunterladen (Punkt 3). Das ist ähnlich wie ollama run . Verwenden Sie export LLAMA_CACHE="folder" um zu erzwingen, dass llama.cpp um an einem bestimmten Ort zu speichern. Denk daran, dass das Modell nur eine maximale Kontextlänge von 200K hat.

Folge dem für allgemeine Instruktions- 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

Folge dem 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 herunter über (nach 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 wir empfehlen unsere 2-Bit-dynamische Quantisierung UD-Q2_K_XL um Größe und Genauigkeit auszugleichen.

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

4

Sie können --threads 32 für die Anzahl der CPU-Threads bearbeiten, --ctx-size 16384 für die Kontextlänge, --n-gpu-layers 2 für das GPU-Offloading für wie viele Schichten. Versuchen Sie, es anzupassen, wenn Ihre GPU nicht mehr genügend Speicher hat. Entfernen Sie es auch, 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 Bereitstellung & OpenAIs Completion-Bibliothek

Um GLM-5 für die Produktion bereitzustellen, verwenden wir llama-server In einem neuen Terminal, z. B. via tmux, deployen Sie das Modell über:

./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 in einem neuen Terminal, nachdem Sie pip install openai, tun Sie:

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 du erhältst folgendes Beispiel eines Snake-Spiels:

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

### Der Code

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Classic Snake Game</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 Game</h1>
    <div id="scoreBoard">Punktzahl: 0</div>
    <canvas id="gameCanvas" width="400" height="400"></canvas>

    <div id="gameOverMenu">
        <h2 style="color: red; margin: 0;">Game Over!</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 Feldes
        const tileCount = canvas.width / gridSize; // Anzahl der Felder 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;

        // Initialisiere das Spiel
        function initGame() {
            snake = [
                {x: 10, y: 10}, 
                {x: 9, y: 10}, 
                {x: 8, y: 10}
            ];
            score = 0;
            scoreBoard.innerText = 'Punktzahl: ' + score;
            dx = 1; // Beginne sofort nach rechts zu bewegen
            dy = 0;
            placeFood();
            isGameRunning = true;
            gameOverMenu.style.display = 'none';
            
            // Starte die Spielschleife
            if (gameInterval) clearInterval(gameInterval);
            gameInterval = setInterval(gameLoop, 100); // Führe die Spielschleife alle 100 ms aus
        }

        // Haupt-Spielschleife
        function gameLoop() {
            if (!isGameRunning) return;

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

        // Bewege die Schlange
        function moveSnake() {
            // Erstelle einen neuen Kopf basierend auf der aktuellen Richtung
            const head = {x: snake[0].x + dx, y: snake[0].y + dy};
            
            // Füge den neuen Kopf am Anfang des Arrays hinzu
            snake.unshift(head);

            // Entferne den Schwanz (letztes Element), es sei denn, Essen wurde gegessen
            // Hinweis: Wir entfernen den Schwanz in checkFoodCollision
            snake.pop(); 
        }

        // Prüfe, ob die Schlange Essen frisst
        function checkFoodCollision() {
            const head = snake[0];
            
            if (head.x === foodX && head.y === foodY) {
                // Wachse: füge ein Schwanzstück hinzu (dupliziere das letzte)
                snake.push({...snake[snake.length - 1]});
                score += 10;
                scoreBoard.innerText = 'Punktzahl: ' + score;
                placeFood();
            }
        }

        // Prüfe auf Kollisionen (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 (prüfe ab dem 4. Segment, 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;
        }

        // Zeichne alles
        function draw() {
            // Leere das Canvas
            ctx.fillStyle = 'black';
            ctx.fillRect(0, 0, canvas.width, canvas.height);

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

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

        // Platziere Essen an zufälliger Position
        function placeFood() {
            foodX = Math.floor(Math.random() * tileCount);
            foodY = Math.floor(Math.random() * tileCount);

            // Stelle sicher, dass das Essen nicht im Körper der Schlange spawnt
            for (let part of snake) {
                if (part.x === foodX && part.y === foodY) {
                    placeFood(); // Finde rekursiv einen neuen Platz
                    return;
                }
            }
        }

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

        // Zurücksetz-Logik
        function resetGame() {
            initGame();
        }

        // Tastatursteuerung
        document.addEventListener('keydown', (e) => {
            // Verhindere Richtungsumkehr (kann nicht links gehen, wenn es rechts geht)
            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;
            }
        });

        // Starte das Spiel beim Laden
        initGame();
    </script>
</body>
</html>
```

### Wie man spielt
1.  **Kopiere den Code** oben.
2.  Erstelle eine neue Datei auf deinem Computer namens `snake.html`.
3.  **Füge den Code ein** in diese Datei und speichere sie.
4.  **Doppelklicke `snake.html`** um sie in deinem Browser zu öffnen.

### Steuerung
*   **Pfeiltasten**: Nach oben, unten, links, rechts bewegen.
*   **Leertaste**: Startet das Spiel (falls es noch nicht gestartet ist).
*   **Nochmal spielen-Button**: Erscheint, wenn du abstürzt, um das Spiel neu zu starten.

### Funktionen dieser Version
*   **Rasterbasiertes Bewegen**: Klassisches Retro-Gefühl.
*   **Punktestand-Verfolgung**: Aktualisiert in Echtzeit.
*   **Game-Over-Bildschirm**: Zeigt deine Endpunktzahl an und ermöglicht ein einfaches Neustarten.
*   **Kollisions-Erkennung**: Beendet das Spiel, wenn du die Wände oder dich selbst triffst.
*   **Selbstkollisions-Schutz**: Der Code verhindert, dass die Schlange sich sofort nach dem Essen aufgrund der in einfachen Tutorials häufig vorkommenden "Schwanzüberspringen"-Logik versehentlich selbst frisst.

💻 vLLM-Bereitstellung

Du kannst jetzt Z.ais FP8-Version des Modells über vLLM bereitstellen. Du brauchst 860GB VRAM oder mehr, daher werden mindestens 8xH200 (141x8 = 1128GB) empfohlen. 8xB200 funktioniert gut. Installiere zunächst vllm nightly:

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%), entferne --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

Du kannst dann 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( # oder AsyncOpenAI
    api_key = openai_api_key,
    base_url = openai_api_base,
)

🔨Tool-Aufrufe mit GLM 5

Siehe Tool Calling Guide für weitere Details zur Durchführung von Tool-Aufrufen. In einem neuen Terminal (wenn Sie tmux verwenden, drücken Sie STRG+B+D) erstellen wir einige Tools wie das Addieren von 2 Zahlen, Ausführen von Python-Code, 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 substract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "Vor langer Zeit in einer weit, weit entfernten Galaxie...",
        "Es gab zwei Freunde, die Faultiere und Code liebten...",
        "Die Welt ging zu Ende, weil jedes Faultier übermenschliche Intelligenz entwickelte...",
        "Unbekannt einem Freund, hatte der andere versehentlich ein Programm geschrieben, um Faultiere zu entwickeln...",
    ])
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,
    "substract_number": substract_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": "substract_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 vom 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"],
            },
        },
    },
]

Dann verwenden wir die unten stehenden Funktionen (kopieren, einfügen und ausführen), 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

Nachdem GLM 5 gestartet wurde via llama-server wie in GLM-5 oder siehe Tool Calling Guide für weitere Details können wir dann einige Tool-Aufrufe machen.

📊 Benchmarks

Unten kannst du weitere 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 Verifiziert	77.8	73.8	73.1	76.8	80.9	76.2	80.0
SWE-bench Mehrsprachig	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 (öffentliche Auswahl)	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