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

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 bei Vision-, Coding-, agentischen und Chat-Aufgaben erreicht. Das hybride Reasoning-Modell mit 1T Parametern benötigt 600 GB Festplattenspeicher, während die quantisierte Unsloth Dynamic 1,8-Bit Version dies auf 240 GB reduziert (-60 % Größe): Kimi-K2.5-GGUF

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

⚙️ Empfohlene Voraussetzungen

Du benötigst >240 GB Festplattenspeicher um den 1-Bit-Quant 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 über SSD/HDD-Offloading ausgeführt werden, aber die Inferenz wird langsamer sein.

Der 1,8-Bit-(UD-TQ1_0)-Quant läuft auf einer einzelnen 24-GB-GPU, wenn du alle MoE-Layer in den System-RAM (oder auf eine schnelle SSD) auslagerst. Mit ~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 voller Präzisionauszuführen, kannst du die 4-Bit- oder 5-Bit-Quants verwenden. Du kannst auch jeden höheren Wert verwenden, nur um auf Nummer sicher zu gehen.

Für starke Leistung solltest du >240 GB einheitlichen Speicher (oder kombinierte RAM+VRAM) anpeilen, um 10+ Token/s zu erreichen. Wenn du darunter liegst, funktioniert es zwar, aber die Geschwindigkeit sinkt (llama.cpp kann weiterhin per mmap/Disk-Offload 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. Beste Faustregel: RAM+VRAM ≈ Quantgröße; andernfalls funktioniert es trotzdem, nur langsamer aufgrund des Offloadings.

🥝 Kimi-K2.5-Anleitung ausführen

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

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

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

Du kannst zur Sicherheit eine höhere Bit-Quantisierung 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 Inferenz von Kimi K2.5:

Standard-Einstellungen (Instant-Modus)	Thinking-Modus
temperature = 0.6	temperature = 1.0
top_p = 0.95	top_p = 0.95
min_p = 0.01	min_p = 0.01

• Setzen Sie die Temperatur 1,0 um Wiederholungen und Inkohärenz zu reduzieren.

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

• Hinweis: Die Verwendung verschiedener Tools kann unterschiedliche Einstellungen erfordern

Wir empfehlen, min_p auf 0,01 zu setzen um das Auftreten unwahrscheinlicher Tokens mit niedrigen Wahrscheinlichkeiten zu unterdrücken. Und repeat penalty deaktivieren oder auf 1,0 setzen falls nötig.

Chat-Template für Kimi K2.5

Ausführen tokenizer.apply_chat_template([{"role": "user", "content": "Was ist 1+1?"},]) ergibt:

<|im_system|>system<|im_middle|>Du bist Kimi, ein KI-Assistent, erstellt von Moonshot AI.<|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 Studio, unserer neuen Open-Source-Web-UI für lokale KI. Mit Unsloth Studio können Sie Modelle lokal ausführen auf MacOS, Windows, Linux und:

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

• Selbstheilendes Tool-Calling + Websuche

• Code-Ausführung (Python, Bash)

• Automatische Inferenz Parameter-Tuning (Temp, Top-p usw.)

• Schnelle CPU-+GPU-Inferenz via llama.cpp

• LLMs trainieren 2x schneller mit 70% weniger VRAM

1

Unsloth installieren

Führen Sie es 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 geht schnell und dauert ungefähr 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 anmelden. Danach 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 Studio Chat Tab und suche nach Kimi-K2.5 in der Suchleiste und lade dein gewünschtes Modell und den gewünschten Quant herunter. Stelle sicher, dass du genug Rechenleistung hast, um das Modell auszuführen.

4

Kimi-K2.5 ausführen

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

Weitere Informationen finden Sie in unserer Unsloth Studio-Inferenzanleitung.

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

Für diese Anleitung verwenden wir den kleinsten 1-Bit-Quant, der 240 GB groß ist. Du kannst die Quantisierung gerne auf 2-Bit, 3-Bit usw. ändern. Um das Modell in nahezu voller Präzisionauszuführen, kannst du die 4-Bit- oder 5-Bit-Quants verwenden. Du kannst auch jeden höheren Wert verwenden, nur um auf Nummer sicher zu gehen.

1. Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den untenstehenden Build-Anweisungen 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 und fahre 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 du llama.cpp direkt zum Laden von Modellen kannst du Folgendes tun: (:UD-TQ1_0) ist der Quantisierungstyp. Du kannst auch über Hugging Face herunterladen (Punkt 3). Dies ist ähnlich zu ollama run . Verwenden Sie export LLAMA_CACHE="folder" um zu erzwingen, dass llama.cpp um an einem bestimmten Speicherort zu speichern.

LLAMA_SET_ROWS=1 macht llama.cpp ein wenig schneller! Verwende es! --fit on ordnet Modelle automatisch und optimal auf all deinen GPUs und CPUs ein.

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 wird das Modell automatisch an dein System anpassen. Wenn du nicht --fit on und du etwa 360 GB gemeinsamen GPU-Speicher hast, entferne -ot ".ffn_.*_exps.=CPU" um maximale Geschwindigkeit zu erreichen.

Verwende --fit on für automatisches Einpassen auf GPUs und CPUs. Wenn das nicht funktioniert, siehe unten:

Bitte probieren Sie -ot ".ffn_.*_exps.=CPU" verwenden, um alle MoE-Layer auf die CPU auszulagern! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer unterzubringen, wenn Sie mehr GPU-Kapazität haben.

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. Dies lagert nur die MoE-Layer für Up-Projektionen aus.

Und schließlich lagern Sie alle Layer aus via -ot ".ffn_.*_exps.=CPU" Dies verwendet 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, Gate-, Up- und Down-MoE-Layer auszulagern, aber nur ab der 6. Schicht.

1. Lade das Modell herunter über (nach der Installation von pip install huggingface_hub hf_transfer ). Wir empfehlen, unseren 2-Bit-Dynamic-Quant 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 2bit

Wenn du feststellst, dass Downloads bei 90 bis 95 % oder so hängen bleiben, sieh dir bitte unsere Fehlerbehebungsanleitung.

1. Führe einen beliebigen Prompt aus.

2. Bearbeiten --ctx-size 16384 für die Kontextlänge an. Du kannst dies auch weglassen für die automatische Ermittlung der Kontextlänge über --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. Versuche beispielsweise: "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>
        
        <!-- Game-Over-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">Zum Neustart klicken</div>
        </div>
        
        <!-- Punktezä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; // Frames
        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');
        
        // Eingabeverarbeitung
        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;
            
            // Physik des Vogels
            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-Generierung
            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;
                }
                
                // Kollisionsprüfung (vereinfachtes Rechteck-Kreis-Modell)
                const pipeWidth = 60;
                const pipeX = pipe.x;
                const pipeLeft = pipeX;
                const pipeRight = pipeX + pipeWidth;
                
                // Vogel ist ein Kreis, Rohre sind Rechtecke
                const birdLeft = bird.x - bird.radius + 4; // +4 für Schnabelversatz
                const birdRight = bird.x + bird.radius + 2;
                const birdTop = bird.y - bird.radius;
                const birdBottom = bird.y + bird.radius;
                
                // Horizontale Kollision prüfen
                if (birdRight > pipeLeft && birdLeft < pipeRight) {
                    // Kollision mit oberem Rohr
                    if (birdTop < pipe.topHeight) {
                        gameOver();
                        return;
                    }
                    // Kollision mit unterem 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 leeren
            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);
            }
            
            // Game-Over-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 der Completion-Bibliothek von OpenAI

Die Verwendung von --kv-unified kann die Inferenzbereitstellung 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.5installiert hast, 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

Verwenden Sie anschließend die Python-Bibliothek von OpenAI nach 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:

Reasoning & Knowledge

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

Coding

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 (Agent Swarm)	78.4	-	-	-	-	-
WideSearch (item-f1)	72.7	-	76.2*	57.0	32.5*	-
WideSearch (item-f1 Agent Swarm)	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*	-

Hinweise

• * = vom Autor neu bewertete Punktzahl (zuvor nicht öffentlich verfügbar).

• † = Die Punktzahl von DeepSeek V3.2 bezieht sich auf dessen Nur-Text-Untermenge (wie in den Fußnoten angegeben).

• - = nicht bewertet / nicht verfügbar.