🥝Kimi K2.5: Leitfaden zum lokalen Ausführen

Leitfaden zum Ausführen von Kimi-K2.5 auf deinem eigenen lokalen Gerät!

Kimi-K2.5 ist das neue Modell von Moonshot, das SOTA-Performance in Vision-, Coding-, agentischen und Chat-Aufgaben erzielt. Das hybride Reasoning-Modell mit 1T Parametern benötigt 600 GB Festplattenspeicher, während die quantisierte Unsloth Dynamic 1,8-Bit Version reduziert dies auf 240 GB (-60 % Größe): Kimi-K2.5-GGUF

Alle Uploads verwenden Unsloth Dynamic 2.0 für SOTA-Aider- und 5-shot-MMLU-Performance. Sieh, wie unsere Dynamic-1–2-Bit-GGUFs auf Coding-Benchmarks.

⚙️ Empfohlene Systemvoraussetzungen

Du benötigst >240 GB Speicherplatz um die 1-Bit-Quantisierung auszuführen!

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

Die 1,8-Bit-Quantisierung (UD-TQ1_0) läuft auf einer einzelnen 24-GB-GPU, wenn du alle MoE-Schichten in den System-RAM (oder eine schnelle SSD) auslagerst. Bei ~256 GB RAM kannst du mit ~10 Token/s rechnen. Das vollständige Kimi-K2.5-Modell ist 630 GB groß und benötigt typischerweise mindestens 4× H200-GPUs.

Wenn das Modell hineinpasst, erhältst du >40 Token/s bei Verwendung einer B200.

Um das Modell in nahezu Vollpräzision, kannst du die 4-Bit- oder 5-Bit-Quants verwenden. Du kannst zur Sicherheit auch eine höhere wählen.

Für starke Performance solltest du >240 GB Unified Memory (oder kombiniertes RAM+VRAM) anstreben, um 10+ Token/s zu erreichen. Wenn du darunter liegst, funktioniert es zwar, aber die Geschwindigkeit sinkt (llama.cpp kann weiterhin über mmap/Disk-Offloading laufen) und kann von ~10 Token/s auf <2 Token/s fallen.

Wir empfehlen UD-Q2_K_XL (375 GB) als guten Kompromiss zwischen Größe und Qualität. Die beste Faustregel: RAM+VRAM ≈ die Größe der Quantisierung; andernfalls funktioniert es weiterhin, nur langsamer wegen des Offloadings.

🥝 Leitfaden für Kimi-K2.5

Kimi-K2.5 benötigt für unterschiedliche Anwendungsfälle unterschiedliche Sampling-Parameter.

Derzeit gibt es keine Vision-Unterstützung für das Modell, aber hoffentlich unterstützt llama.cpp es bald.

Um das Modell in Vollpräzision auszuführen, musst du nur die 4-Bit- oder 5-Bit-Dynamic-GGUFs (z. B. UD_Q4_K_XL) verwenden, da das Modell ursprünglich im INT4-Format veröffentlicht wurde.

Du kannst zur Sicherheit eine Quantisierung mit höherer Bitzahl wählen, falls es kleine Quantisierungsunterschiede gibt, aber in den meisten Fällen ist das unnötig.

🌙 Nutzungsanleitung:

Laut Moonshot AI sind dies die empfohlenen Einstellungen für die Kimi-K2.5-Inferenz:

Standardeinstellungen (Sofortmodus)	Denkmodus
temperature = 0.6	temperature = 1.0
top_p = 0.95	top_p = 0.95
min_p = 0.01	min_p = 0.01

• Setze die Temperatur auf 1.0 um Wiederholungen und Inkohärenz zu reduzieren.

• Empfohlene Kontextlänge = 98.304 (bis zu 256K)

• Hinweis: Die Verwendung verschiedener Tools kann andere Einstellungen erfordern

Wir empfehlen, min_p auf 0.01 um das Auftreten unwahrscheinlicher Tokens mit niedrigen Wahrscheinlichkeiten zu unterdrücken. Und deaktiviere oder setze repeat penalty = 1.0 falls nötig.

Chat-Vorlage für Kimi K2.5

Ausführen tokenizer.apply_chat_template([{"role": "user", "content": "What is 1+1?"},]) erhältst du:

<|im_system|>system<|im_middle|>Du bist Kimi, ein von Moonshot AI erstellter KI-Assistent.<|im_end|><|im_user|>user<|im_middle|>Was ist 1+1?<|im_end|><|im_assistant|>assistant<|im_middle|><think>

🦥 Kimi-K2.5 in Unsloth Studio ausführen

Kimi-K2.5 kann ausgeführt werden in Unsloth Studiounserer neuen Open-Source-Web-UI für lokale KI ausgeführt und feinabgestimmt werden. Mit Unsloth Studio können Sie Modelle lokal auf MacOS, Windows, Linux und:

• Suchen, herunterladen, GGUFs ausführen und Safetensor-Modelle

• Selbstheilende Tool-Aufrufe + Websuche

• Code-Ausführung (Python, Bash)

• Automatische Inferenz Parametertuning (Temp, Top-P usw.)

• Schnelle CPU- + GPU-Inferenz über llama.cpp

• LLMs trainieren 2x schneller mit 70 % weniger VRAM

1

Unsloth installieren

Führen Sie dies in Ihrem Terminal aus:

macOS, Linux, WSL:

curl -fsSL https://unsloth.ai/install.sh | sh

Windows PowerShell:

irm https://unsloth.ai/install.ps1 | iex

Die Installation wird schnell sein und dauert ca. 1–2 Minuten.

2

Unsloth starten

MacOS, Linux, WSL und Windows:

unsloth studio -H 0.0.0.0 -p 8888

Dann öffnen Sie http://localhost:8888 in Ihrem Browser.

3

Kimi-K2.5 suchen und herunterladen

Beim ersten Start musst du ein Passwort erstellen, um dein Konto zu sichern und dich später erneut anzumelden. Anschließend siehst du einen kurzen Einrichtungsassistenten, um ein Modell, einen Datensatz und grundlegende Einstellungen auszuwählen. Du kannst ihn jederzeit überspringen und direkt zum Chat gehen.

Gehen Sie dann zur Unsloth Chat Registerkarte und suche nach Kimi-K2.5 in der Suchleiste und lade dein gewünschtes Modell und deine gewünschte Quantisierung herunter. Stelle sicher, dass du genügend Rechenleistung hast, um das Modell auszuführen.

4

Kimi-K2.5 ausführen

Die Inferenzparameter sollten bei Verwendung von Unsloth Studio automatisch gesetzt werden, Sie können sie jedoch weiterhin manuell ändern. Sie können auch die Kontextlänge, das Chat-Template und andere Einstellungen bearbeiten.

Weitere Informationen finden Sie in unserer Unsloth-Studio-Inferenzanleitung.

✨ Kimi K2.5 in llama.cpp ausführen

Für diesen Leitfaden verwenden wir die kleinste 1-Bit-Quantisierung, die 240 GB groß ist. Du kannst den Quantisierungstyp gern auf 2-Bit, 3-Bit usw. ändern. Um das Modell in nahezu Vollpräzision, kannst du die 4-Bit- oder 5-Bit-Quants verwenden. Du kannst zur Sicherheit auch eine höhere wählen.

1. Holen Sie sich die neueste llama.cpp auf GitHub hier. Sie können auch den folgenden Build-Anweisungen folgen. Ä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

1. Wenn Sie llama.cpp direkt Modelle zu laden, kannst du Folgendes tun: (:UD-TQ1_0) 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, llama.cpp dass an einem bestimmten Speicherort gespeichert wird.

LLAMA_SET_ROWS=1 macht llama.cpp ein wenig schneller! Nutze es! --fit on passt Modelle automatisch optimal auf all deine GPUs und CPUs an.

export LLAMA_CACHE="unsloth/Kimi-K2.5-GGUF"
LLAMA_SET_ROWS=1 ./llama.cpp/llama-cli \\
    -hf unsloth/Kimi-K2.5-GGUF:UD-TQ1_0\\
    --temp 1.0 \\
    --min-p 0.01 \
    --top-p 0.95 \
    --ctx-size 16384 \
    --seed 3407

1. --fit on passt das Modell automatisch an dein System an. Wenn du nicht --fit on und du ungefähr 360 GB kombinierten GPU-Speicher hast, entferne -ot ".ffn_.*_exps.=CPU" um maximale Geschwindigkeit zu erreichen.

Verwenden Sie --fit on für das automatische Anpassen an GPUs und CPUs. Wenn das nicht funktioniert, siehe unten:

Bitte probiere -ot ".ffn_.*_exps.=CPU" um alle MoE-Schichten auf die CPU auszulagern! Dadurch kannst du effektiv alle Nicht-MoE-Schichten auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Du kannst den Regex-Ausdruck anpassen, um mehr Schichten unterzubringen, wenn du mehr GPU-Kapazität hast.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie -ot ".ffn_(up|down)_exps.=CPU" Dies lagert die MoE-Layer für Up- und Down-Projektionen aus.

Versuchen Sie -ot ".ffn_(up)_exps.=CPU" wenn Sie noch mehr GPU-Speicher haben. Dadurch werden nur die MoE-Layer für Up-Projektionen ausgelagert.

Und schließlich lagere alle Schichten via -ot ".ffn_.*_exps.=CPU" Das verbraucht am wenigsten VRAM.

Sie können den Regex auch anpassen, zum Beispiel -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" bedeutet, dass Gate-, Up- und Down-MoE-Layer ausgelagert werden, aber erst ab der 6. Schicht.

1. Laden Sie das Modell über herunter (nach der Installation von pip install huggingface_hub hf_transfer ). Wir empfehlen, unsere dynamische 2-Bit-Quantisierung UD-Q2_K_XL zu verwenden, um Größe und Genauigkeit auszubalancieren. Alle Versionen unter: huggingface.co/unsloth/Kimi-K2.5-GGUF Wenn Downloads hängen bleiben, siehe Hugging Face Hub, XET-Debugging

pip install -U huggingface_hub
hf download unsloth/Kimi-K2.5-GGUF \\
    --local-dir unsloth/Kimi-K2.5-GGUF \\
    --include "*UD-TQ1_0*" # Verwende "*UD-Q2_K_XL*" für Dynamic 2-Bit

Wenn du feststellst, dass Downloads bei etwa 90 bis 95 % hängen bleiben, siehe bitte unsere Fehlerbehebungsanleitung.

1. Beliebigen Prompt ausführen.

2. Bearbeiten --ctx-size 16384 für die Kontextlänge. Du kannst dies auch weglassen, um die automatische Ermittlung der Kontextlänge via --fit on

LLAMA_SET_ROWS=1 ./llama.cpp/llama-cli \\
    --model unsloth/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf \\
    --temp 1.0 \\
    --min-p 0.01 \
    --top-p 0.95 \
    --ctx-size 16384 \
    --seed 3407

1. Als Beispiel probiere: "Erstelle ein Flappy-Bird-Spiel in HTML", und du erhältst:

<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flappy Bird</title>
    <style>
        body {
            margin: 0;
            padding: 0;
            background: #222;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            font-family: 'Segoe UI', sans-serif;
            overflow: hidden;
            touch-action: none;
        }
        
        #game-container {
            position: relative;
            width: 400px;
            height: 600px;
            background: linear-gradient(to bottom, #70c5ce 0%, #70c5ce 80%, #c23810 80%, #c23810 100%);
            box-shadow: 0 0 20px rgba(0,0,0,0.5);
            overflow: hidden;
        }
        
        canvas {
            display: block;
        }
        
        .overlay {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            text-align: center;
            color: white;
            text-shadow: 2px 2px 0 #000;
            font-weight: bold;
            pointer-events: none;
        }
        
        .game-title {
            font-size: 48px;
            margin-bottom: 20px;
        }
        
        .score-display {
            font-size: 36px;
            margin-bottom: 10px;
        }
        
        .best-score {
            font-size: 24px;
            color: #ffe;
        }
        
        .instruction {
            font-size: 20px;
            animation: pulse 1s infinite;
        }
        
        @keyframes pulse {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.5; }
        }
        
        .hidden { display: none; }
    </style>
</head>
<body>
    <div id="game-container">
        <canvas id="canvas" width="400" height="600"></canvas>
        
        <!-- Startbildschirm -->
        <div id="start-screen" class="overlay">
            <div class="game-title">FLAPPY BIRD</div>
            <div class="instruction">Klicken oder Leertaste zum Fliegen</div>
        </div>
        
        <!-- Spielende-Bildschirm -->
        <div id="game-over-screen" class="overlay hidden">
            <div class="game-title">SPIEL VORBEI</div>
            <div class="score-display">Punktestand: <span id="final-score">0</span></div>
            <div class="best-score">Bestwert: <span id="best-score">0</span></div>
            <div class="instruction">Klicken zum Neustart</div>
        </div>
        
        <!-- Punktzähler -->
        <div id="current-score" class="overlay hidden" style="top: 10%; font-size: 72px; color: white; text-shadow: 4px 4px 0 #000;">
            0
        </div>
    </div>

    <script>
        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d');
        
        // Spielkonstanten
        const GRAVITY = 0.4;
        const JUMP_STRENGTH = -7;
        const PIPE_SPEED = 3;
        const PIPE_SPAWN_RATE = 120; // Bildrahmen
        const PIPE_GAP = 120;
        
        // Spielzustand
        let bird = { x: 50, y: 200, velocity: 0, radius: 15, wingState: 0 };
        let pipes = [];
        let score = 0;
        let bestScore = localStorage.getItem('flappyBest') || 0;
        let frameCount = 0;
        let isGameOver = false;
        let isPlaying = false;
        
        // DOM-Elemente
        const startScreen = document.getElementById('start-screen');
        const gameOverScreen = document.getElementById('game-over-screen');
        const currentScoreDisplay = document.getElementById('current-score');
        const finalScoreEl = document.getElementById('final-score');
        const bestScoreEl = document.getElementById('best-score');
        
        // Eingabebehandlung
        function handleInput(e) {
            if (!isPlaying) {
                if (isGameOver) {
                    resetGame();
                }
                startGame();
            } else if (!isGameOver) {
                bird.velocity = JUMP_STRENGTH;
                bird.wingState = 1;
            }
        }
        
        document.addEventListener('keydown', (e) => {
            if (e.code === 'Space' || e.code === 'ArrowUp') handleInput(e);
        });
        canvas.addEventListener('pointerdown', handleInput);
        
        function startGame() {
            isPlaying = true;
            isGameOver = false;
            startScreen.classList.add('hidden');
            currentScoreDisplay.classList.remove('hidden');
            resetGameState();
            gameLoop();
        }
        
        function resetGameState() {
            bird = { x: 50, y: 200, velocity: 0, radius: 15, wingState: 0 };
            pipes = [];
            score = 0;
            frameCount = 0;
            currentScoreDisplay.textContent = score;
        }
        
        function resetGame() {
            isGameOver = false;
            isPlaying = true;
            gameOverScreen.classList.add('hidden');
            currentScoreDisplay.classList.remove('hidden');
            resetGameState();
            gameLoop();
        }
        
        function spawnPipe() {
            const minHeight = 100;
            const maxHeight = 400;
            const topHeight = Math.floor(Math.random() * (maxHeight - minHeight + 1) + minHeight);
            const bottomHeight = canvas.height - topHeight - PIPE_GAP;
            
            pipes.push({
                x: canvas.width,
                topHeight: topHeight,
                bottomY: topHeight + PIPE_GAP,
                bottomHeight: bottomHeight,
                passed: false
            });
        }
        
        function update() {
            if (isGameOver) return;
            
            // Vogelphysik
            bird.velocity += GRAVITY;
            bird.y += bird.velocity;
            
            // Kollision mit Boden/Decke
            if (bird.y + bird.radius > canvas.height || bird.y - bird.radius < 0) {
                gameOver();
                return;
            }
            
            // Rohr-Erzeugung
            frameCount++;
            if (frameCount % PIPE_SPAWN_RATE === 0) {
                spawnPipe();
            }
            
            // Rohrbewegung und Kollision
            for (let i = pipes.length - 1; i >= 0; i--) {
                const pipe = pipes[i];
                pipe.x -= PIPE_SPEED;
                
                // Rohre außerhalb des Bildschirms entfernen
                if (pipe.x + 60 < 0) {
                    pipes.splice(i, 1);
                    continue;
                }
                
                // Kollisionsdetektion (vereinfachtes Rechteck-Kreis-Modell)
                const pipeWidth = 60;
                const pipeX = pipe.x;
                const pipeLeft = pipeX;
                const pipeRight = pipeX + pipeWidth;
                
                // Der Vogel ist ein Kreis, die Rohre sind Rechtecke
                const birdLeft = bird.x - bird.radius + 4; // +4 für den Schnabelversatz
                const birdRight = bird.x + bird.radius + 2;
                const birdTop = bird.y - bird.radius;
                const birdBottom = bird.y + bird.radius;
                
                // Horizontale Kollisionsprüfung
                if (birdRight > pipeLeft && birdLeft < pipeRight) {
                    // Kollision mit dem oberen Rohr
                    if (birdTop < pipe.topHeight) {
                        gameOver();
                        return;
                    }
                    // Kollision mit dem unteren Rohr
                    if (birdBottom > pipe.bottomY) {
                        gameOver();
                        return;
                    }
                }
                
                // Punkte zählen
                if (pipe.x + pipeWidth < bird.x && !pipe.passued) {
                    pipe.passed = true;
                    score++;
                    currentScoreDisplay.textContent = score;
                }
            }
            
            // Flügel animieren
            if (bird.wingState > 0) {
                bird.wingState = (bird.wingState + 0.2) % 2;
            }
        }
        
        function draw() {
            // Canvas löschen
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            
            // Rohre zeichnen
            pipes.forEach(pipe => {
                // Oberes Rohr
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, 0, 60, pipe.topHeight);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.topHeight - 20, 60, 20); // Kappe
                
                // Unteres Rohr
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, pipe.bottomY, 60, canvas.height - pipe.bottomY);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.bottomY - 20, 60, 20); // Kappe
            });
            
            // Vogel zeichnen (Kreis mit Schnabel)
            ctx.fillStyle = '#e3bc4e';
            ctx.beginPath();
            ctx.arc(bird.x, bird.y, bird.radius, 0, Math.PI * 2);
            ctx.fill();
            
            // Schnabel
            ctx.fillStyle = '#e04c4c';
            ctx.beginPath();
            ctx.moveTo(bird.x + bird.radius - 4, bird.y - 4);
            ctx.lineTo(bird.x + bird.radius + 10, bird.y);
            ctx.lineTo(bird.x + bird.radius - 4, bird.y + 4);
            ctx.fill();
            
            // Augen
            ctx.fillStyle = 'black';
            ctx.beginPath();
            ctx.arc(bird.x + 5, bird.y - 6, 3, 0, Math.PI * 2);
            ctx.fill();
            
            // Flügel
            ctx.fillStyle = '#c4a';
            ctx.beginPath();
            ctx.ellipse(bird.x - 5, bird.y + 5, 10, 6, 0, 0, Math.PI * 2);
            ctx.fill();
        }
        
        function gameOver() {
            isGameOver = true;
            isPlaying = false;
            
            // Besten Punktestand aktualisieren
            if (score > bestScore) {
                bestScore = score;
                localStorage.setItem('flappyBest', bestScore);
            }
            
            // Spielende-Bildschirm anzeigen
            currentScoreDisplay.classList.add('hidden');
            gameOverScreen.classList.remove('hidden');
            finalScoreEl.textContent = score;
            bestScoreEl.textContent = bestScore;
        }
        
        function gameLoop() {
            if (!isPlaying) return;
            
            update();
            draw();
            requestAnimationFrame(gameLoop);
        }
        
        // Erste Zeichnung
        draw();
    </script>
</body>
</html>

✨ Bereitstellen mit llama-server und OpenAIs Completion-Bibliothek

Die Verwendung von --kv-unified kann das Inferenz-Serving in llama.cpp schneller machen! Siehe https://www.reddit.com/r/LocalLLaMA/comments/1qnwa33/glm_47_flash_huge_performance_improvement_with_kvu/

Nachdem du llama.cpp gemäß Kimi K2.5, kannst du Folgendes verwenden, um einen OpenAI-kompatiblen Server zu starten:

LLAMA_SET_ROWS=1 ./llama.cpp/llama-server \\
    --model unsloth/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf \\
    --special \\
    --alias "unsloth/Kimi-K2.5" \\
    --min-p 0.01 \
    --ctx-size 16384 \
    --port 8001 \\
    --kv-unified

Dann verwende anschließend OpenAIs Python-Bibliothek pip install openai :

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/Kimi-K2.5",
    messages = [{"role": "user", "content": "Was ist 1+1?"},],
)
print(completion.choices[0].message.content)

Und wir erhalten:

Und im anderen llama-server-Fenster:

📊 Benchmarks

Du kannst weiter unten Benchmarks in Tabellenform ansehen:

Schlussfolgern & Wissen

Benchmark	Kimi K2.5	GPT-5.2	Claude 4.5 Opus	Gemini 3 Pro	DeepSeek V3.2	Qwen3-VL-235B-A22B-Thinking
HLE-Full	30.1	34.5	30.8	37.5	25.1†	-
HLE-Full (mit Tools)	50.2	45.5	43.2	45.8	40.8†	-
AIME 2025	96.1	100	92.8	95.0	93.1	-
HMMT 2025 (Feb)	95.4	99.4	92.9*	97.3*	92.5	-
IMO-AnswerBench	81.8	86.3	78.5*	83.1*	78.3	-
GPQA-Diamond	87.6	92.4	87.0	91.9	82.4	-
MMLU-Pro	87.1	86.7*	89.3*	90.1	85.0	-

Bild & Video

Benchmark	Kimi K2.5	GPT-5.2	Claude 4.5 Opus	Gemini 3 Pro	DeepSeek V3.2	Qwen3-VL-235B-A22B-Thinking
MMMU-Pro	78.5	79.5*	74.0	81.0	-	69.3
CharXiv (RQ)	77.5	82.1	67.2*	81.4	-	66.1
MathVision	84.2	83.0	77.1*	86.1*	-	74.6
MathVista (mini)	90.1	82.8*	80.2*	89.8*	-	85.8
ZeroBench	9	9*	3*	8*	-	4*
ZeroBench (mit Tools)	11	7*	9*	12*	-	3*
OCRBench	92.3	80.7*	86.5*	90.3*	-	87.5
OmniDocBench 1.5	88.8	85.7	87.7*	88.5	-	82.0*
InfoVQA (val)	92.6	84*	76.9*	57.2*	-	89.5
SimpleVQA	71.2	55.8*	69.7*	69.7*	-	56.8*
WorldVQA	46.3	28.0	36.8	47.4	-	23.5
VideoMMMU	86.6	85.9	84.4*	87.6	-	80.0
MMVU	80.4	80.8*	77.3	77.5	-	71.1
MotionBench	70.4	64.8	60.3	70.3	-	-
VideoMME	87.4	86.0*	-	88.4*	-	79.0
LongVideoBench	79.8	76.5*	67.2*	77.7*	-	65.6*
LVBench	75.9	-	-	73.5*	-	63.6

Programmierung

Benchmark	Kimi K2.5	GPT-5.2	Claude 4.5 Opus	Gemini 3 Pro	DeepSeek V3.2	Qwen3-VL-235B-A22B-Thinking
SWE-Bench Verified	76.8	80.0	80.9	76.2	73.1	-
SWE-Bench Pro	50.7	55.6	55.4*	-	-	-
SWE-Bench Multilingual	73.0	72.0	77.5	65.0	70.2	-
Terminal Bench 2.0	50.8	54.0	59.3	54.2	46.4	-
PaperBench	63.5	63.7*	72.9*	-	47.1	-
CyberGym	41.3	-	50.6	39.9*	17.3*	-
SciCode	48.7	52.1	49.5	56.1	38.9	-
OJBench (cpp)	57.4	-	54.6*	68.5*	54.7*	-
LiveCodeBench (v6)	85.0	-	82.2*	87.4*	83.3	-

Langer Kontext

Benchmark	Kimi K2.5	GPT-5.2	Claude 4.5 Opus	Gemini 3 Pro	DeepSeek V3.2	Qwen3-VL-235B-A22B-Thinking
Longbench v2	61.0	54.5*	64.4*	68.2*	59.8*	-
AA-LCR	70.0	72.3*	71.3*	65.3*	64.3*	-

Agentische Suche

Benchmark	Kimi K2.5	GPT-5.2	Claude 4.5 Opus	Gemini 3 Pro	DeepSeek V3.2	Qwen3-VL-235B-A22B-Thinking
BrowseComp	60.6	65.8	37.0	37.8	51.4	-
BrowseComp (mit Kontextverwaltung)	74.9	65.8	57.8	59.2	67.6	-
BrowseComp (Agentenschwarm)	78.4	-	-	-	-	-
WideSearch (item-f1)	72.7	-	76.2*	57.0	32.5*	-
WideSearch (item-f1 Agentenschwarm)	79.0	-	-	-	-	-
DeepSearchQA	77.1	71.3*	76.1*	63.2*	60.9*	-
FinSearchCompT2&T3	67.8	-	66.2*	49.9	59.1*	-
Seal-0	57.4	45.0	47.7*	45.5*	49.5*	-

Anmerkungen

• * = von den Autoren neu berechneter Score (zuvor nicht öffentlich verfügbar).

• † = Der DeepSeek-V3.2-Score entspricht seinem Nur-Text-Teildatensatz (wie in den Fußnoten vermerkt).

• - = nicht bewertet / nicht verfügbar.