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 Leistungen beim Codieren, bei Agenten und im Chat als GLM-4.7und ist für langkontextuelles Schlussfolgern ausgelegt. Es verbessert die Leistung bei Benchmarks wie Humanity's Last Exam 50,4% (+7,6%), BrowseComp 75,9% (+8,4%) und Terminal-Bench-2.0 61,1% (+28,3%).

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

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

⚙️ Gebrauchsanleitung

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.

Für beste Leistung stellen Sie sicher, dass Ihr insgesamt verfügbarer Speicher (VRAM + Systemspeicher) die Größe der quantisierten Modell-Datei, die Sie herunterladen, übersteigt. Wenn dies nicht der Fall ist, kann llama.cpp weiterhin über 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 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 mehrturnige agentische Aufgaben (τ²-Bench und Terminal Bench 2) aktivieren Sie bitte den Preserved Thinking-Modus.

Führen Sie GLM-5 Tutorials aus:

✨ In llama.cpp ausführen

1

Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den Build-Anweisungen unten folgen. Ändere -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn du keine GPU hast oder nur CPU-Inferenz möchtest. Für Apple Mac / Metal-Geräte, setze -DGGML_CUDA=OFF 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 du llama.cpp direkt zum Laden von Modellen können Sie Folgendes tun: (:IQ2_XXS) ist der Quantisierungstyp. Sie können auch über Hugging Face herunterladen (Punkt 3). Dies ist ähnlich wie ollama run . Verwenden Sie export LLAMA_CACHE="folder" um llama.cpp um an einen bestimmten Ort zu speichern. Denken Sie daran, dass das Modell nur eine maximale Kontextlänge von 200K hat.

Folgen Sie dem für allgemeine Anweisungs- 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

Folgen Sie 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 (nach der Installation pip install huggingface_hub hf_transfer ). Sie können wählen empfehlen die Verwendung unseres 2,7-Bit Dynamic Quant (dynamische 2-Bit-Quant.) oder andere quantisierte Versionen wie UD-Q4_K_XL Q4_K_XL empfehlen wir unsere 2-Bit-dynamische Quantisierung empfehlen die Verwendung unseres 2,7-Bit Dynamic Quant UD-Q2_K_XL. Falls Downloads hängen bleiben, siehe Hugging Face Hub, XET-Debugging

um Größe und Genauigkeit auszubalancieren
hf download unsloth/GLM-5-GGUF \
    --local-dir unsloth/GLM-5-GGUF \
    --include "*UD-IQ2_XXS*" # Verwenden Sie "*UD-TQ1_0*" für dynamisches 1-Bit

4

--include "*UD-Q2_K_XL*" # Verwenden Sie "*UD-TQ1_0*" für Dynamic 1bit Sie können --threads 32 für die Anzahl der CPU-Threads bearbeiten, --ctx-size 16384 für Kontextlänge, --n-gpu-layers 2

./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, deploye das Modell via:

./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 du pip install openai, mache:

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 folgendes Beispiel für ein Snake-Spiel:

Hier ist ein vollständiges, spielbares Snake-Spiel in einer einzigen HTML-Datei. Sie können diesen Code kopieren, als `.html`-Datei (z. B. `snake.html`) speichern und in Ihrem 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">Punktestand: 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">Endpunktestand: 0</p>
        <button onclick="resetGame()">Nochmals 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 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;

        // Initialisiere das Spiel
        function initGame() {
            snake = [
                {x: 10, y: 10}, 
                {x: 9, y: 10}, 
                {x: 8, y: 10}
            ];
            score = 0;
            scoreBoard.innerText = 'Punktestand: ' + score;
            dx = 1; // Beginnt 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); // Spielschleife alle 100 ms ausführen
        }

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

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

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

            // Entferne den Schwanz (letztes Element), es sei denn, Essen wurde gefressen
            // 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) {
                // Wächst die Schlange: Füge ein Schwanzstück hinzu (dupliziere das letzte)
                snake.push({...snake[snake.length - 1]});
                score += 10;
                scoreBoard.innerText = 'Punktestand: ' + score;
                placeFood();
            }
        }

        // Prüfe auf Kollisionen (Wände oder mit 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 (Überprüfung beginnt beim 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 die Leinwand
            ctx.fillStyle = 'black';
            ctx.fillRect(0, 0, canvas.width, canvas.height);

            // Zeichne das 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 etwas 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 auf dem Schlangenkörper erscheint
            for (let part of snake) {
                if (part.x === foodX && part.y === foodY) {
                    placeFood(); // Rekursiv einen neuen Platz finden
                    return;
                }
            }
        }

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

        // Spiel zurücksetzen
        function resetGame() {
            initGame();
        }

        // Tastatursteuerung
        document.addEventListener('keydown', (e) => {
            // Verhindere Richtungsumkehr (kann nicht nach links gehen, wenn nach rechts bewegt wird)
            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>
```

### Spielanleitung
1.  **Kopieren Sie den obigen Code**.
2.  Erstellen Sie auf Ihrem Computer eine neue Datei namens `snake.html`.
3.  **Fügen Sie den Code ein** in diese Datei 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).
*   **Play-Again-Button**: Erscheint, wenn Sie abstürzen, um das Spiel neu zu starten.

### Funktionen dieser Version
*   **Gitterbasierte Bewegung**: Klassisches Retro-Gefühl.
*   **Punktestand-Verfolgung**: Aktualisiert in Echtzeit.
*   **Game-Over-Bildschirm**: Zeigt Ihren Endpunktestand an und ermöglicht ein einfaches Neustarten.
*   **Kollisionsdetektion**: Beendet das Spiel, wenn Sie die Wände oder sich selbst treffen.
*   **Selbstkollisions-Sicherheit**: Der Code verhindert, dass die Schlange sich unmittelbar nach dem Fressen wegen der in einfachen Tutorials häufig vorkommenden "Schwanzüberspringen"-Logik versehentlich selbst frisst.

💻 vLLM-Bereitstellung

Sie können jetzt Z.ais FP8-Version des Modells über vLLM bereitstellen. Sie benötigen 860GB VRAM oder mehr, daher werden mindestens 8xH200 (141x8 = 1128GB) empfohlen. 8xB200 funktionieren gut. Installieren Sie zuerst 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%), 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

Sie können das bereitgestellte Modell dann ü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

Tool Calling mit GLM 4.7 Tool Calling Guide Siehe

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 entfernten Galaxie...",
        "Es waren zwei Freunde, die Faultiere und Code liebten...",
        "Die Welt ging unter, weil jedes Faultier übermenschliche Intelligenz entwickelte...",
        "Ohne dass ein Freund es wusste, hatte der andere versehentlich ein Programm geschrieben, das Faultiere evolvieren ließ...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Kann Befehle 'rm, sudo, dd, chmod' nicht ausführen, da sie gefährlich sind"
        print(msg); return msg
    print(f"Führe Terminal-Befehl `{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 du starten möchtest, z. B. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Rufe 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"],
            },
        },
    },
]

"required": ["code"],

from openai import OpenAI
Wir verwenden dann die folgenden Funktionen (kopieren, einfügen und ausführen), die die Funktionsaufrufe automatisch parsen und den OpenAI-Endpunkt für ein beliebiges Modell aufrufen:
    def unsloth_inference(
    temperature = 1.0,
    temperature = 0.7,
    top_k = -1,
    top_k = 40,
    min_p = 0.01,
):
    repetition_penalty = 1.0,
    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,
            temperature = temperature,
            tools = tools if tools else None,
            tool_choice = "auto" if tools else None,
            tool_choice = "auto" if tools else None,
        )
        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
    has_tool_calls = False

Nachdem GLM 5 gestartet wurde über llama-server llama-server GLM-5 wie in Tool Calling Guide für weitere Details können wir dann einige Tool-Aufrufe durchführen.

📊 Benchmarks

Weiter unten finden Sie Benchmarks in Tabellenform:

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 Menge)	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