← Alle Artikel

Messlabor — was lokale Modelle wirklich können

Measurement Lab — What Local Models Can Really Do

Auf Zuse laufen Modelle nicht nur, sie werden auch gemessen. Ich traue keinem Benchmark, den ich nicht selbst gefahren habe — und, wie sich herausstellte, denen auch nicht immer. Sieben Messreihen, und am Ende bleibt jedes Mal derselbe Satz übrig.

1. Der eigene Quant — und der kaputte Benchmark

Ich habe Qwen3.8-27B selbst auf int4 (AutoRound) quantisiert, um es fair gegen den Vorgänger Qwen3.6 zu vergleichen. Auf einer einzelnen 3090 dauert das gut anderthalb Stunden.

Der erste Durchlauf sagte: Das neue Modell ist beim Coding schlechter, 11 von 13 gegen 13 von 13. Mein erster Gedanke war nicht „schlechtes Modell“, sondern „wenn das Messgerät Fehler hat, sagt das Ergebnis nichts“. Es waren drei Fehler, alle im eigenen Messaufbau:

  • ein Token-Deckel, der für das Nachdenken des Modells zu knapp war,
  • ein deutsches Dezimalkomma, das beim Auswerten weggeputzt wurde,
  • eine Antwort im LaTeX-Format, die der Parser nicht verstand.

Nach der Reparatur: 13 von 13 beim Coding, 12 von 12 in Mathe, gleiche Geschwindigkeit. Der Vorgänger kam auf 12 von 13 und mindestens 8 von 12. Der Quant liegt öffentlich auf Hugging Face: MKRWW/Qwen3.8-27B-int4-AutoRound.

2. Coder-Benchmark: 27B gegen 176B

Aufgaben im Stil von Loopwright — Spec, Abnahmekriterien, Verbotsliste —, gemessen gegen versteckte Abnahmetests, die vorher an einer Referenzlösung validiert wurden. Derselbe lokale Coding-Agent, einmal mit Qwen3.8-27B auf zwei Karten, einmal mit Qwen3.8-Flash-Next (176B MoE, 2-Bit) auf einer Karte.

Aufgabe versteckte Tests 27B Flash-Next
A: neues Modul, Rate-Limiter beide 100 % ~137 s ~105 s
B: Bestandsdatei erweitern, Kassenbuch mit Währungen beide 100 % ~169 s ~116 s
C: Cron-Parser mit Randfällen, 48 Tests, je 3 Läufe beide 48 von 48 718 s 212 s
D: Shop über sechs Dateien plus Bugfix, 23 Tests, je 3 Läufe beide 23 von 23 354 s 161 s

(Zeiten: Mittelwert bei A und B, Median bei C und D.)

Qualität gleich, Flash-Next zwei- bis dreimal schneller. Deshalb ist es der Standard-Coder, wenn die dritte Karte frei ist. Die Unterschiede liegen im Stil: Das 27B schreibt mehr eigene Tests (bis zu 42), Flash-Next genau das Minimum — und Fehlermeldungen gern auf Englisch.

3. Größer ist nicht automatisch besser

Ein paar Wochen vorher sah es noch anders aus. Mit der Engine von damals lief Flash-Next über drei Karten verteilt, und ich habe es mit 23 Alltagsaufgaben gegen das 27B gestellt:

Flash-Next 27B
objektiv prüfbar richtig 17 von 17 17 von 17
kurzer Prompt 52 tok/s 69 tok/s
Prompt mit 30K Token 16 tok/s 42 tok/s

Das größere Modell war nicht besser, und bei langem Kontext deutlich langsamer. Unterwegs habe ich zwei Messfallen gelernt: Ein Modell, das ins Token-Limit läuft, liefert keinen Inhalt — das ist kein falsches Ergebnis, sondern ein zu knappes Budget. Und wer wissen will, welches Modell gesprächiger ist, zählt die erzeugten Token, nicht die sichtbaren Denkschritte. Hier erzeugte das 27B 1,6-mal so viele.

4. 176B auf gebrauchten Grafikkarten

Flash-Next hat 176 Milliarden Parameter, aktiv sind pro Token nur 6 Milliarden. Der offizielle Weg — ein FP8-Checkpoint mit 173 GiB — ist auf Ampere-Karten unmöglich. Über GGUF ging es doch: knapp 79 GB Modell auf 72 GB VRAM plus Arbeitsspeicher.

Der Schlüssel war ein einziger Tensor: 28,8 GB Embeddings, die in den Arbeitsspeicher gehören, nicht auf die Karten. Und die Ladestrategie: ohne Memory-Mapping war das Ganze sechsmal schneller. Ergebnis damals: 38,5 tok/s über drei Karten.

Heute läuft dasselbe Modell mit einer Engine, die die Experten im Arbeitsspeicher hält und auf der Karte nur die gerade gebrauchten vorhält — auf einer einzigen 3090, mit 66 bis 94 tok/s.

5. Beschleuniger: Sieg im Benchmark, Niederlage im Alltag

Spekulatives Decoding rät mehrere Token voraus und lässt das große Modell nur noch prüfen. Drei Versuche:

  • Der eingebaute Vorhersage-Kopf des Modells, drei Token voraus: +33 % allein, +23 % bei vier parallelen Anfragen, 62 % Trefferquote.
  • Ein externer Block-Diffusion-Drafter: im synthetischen Benchmark 2,18-mal so schnell, im echten Alltag — Deutsch, Code und Agenten gemischt — langsamer. Zurückgerollt.
  • Ein externer Draft-Kopf auf meinem int4-Quant: 13,7 % Trefferquote, 43 % langsamer.

Spekulatives Decoding lebt von der Trefferquote, und die hängt an der eigenen Last, nicht am Benchmark des Herstellers.

6. LoRA I: Was kauft Training?

Für die NPCs im BOFH Simulator habe ich ein kleines Modell auf den Charakter trainiert: 4B-Basis, LoRA, fertig als GGUF mit 2,5 GB. Die Basis ist eine Variante, aus der die pauschalen Verweigerungen herausgerechnet wurden. Den Ton bringt das Training.

Die naheliegende Frage: Spielt ein gutes Modell mit gutem Prompt den Charakter nicht genauso gut? Gemessen über sieben Rollen, von harmlosen bis zu dunklen Tickets, dazu ein Gespräch über mehrere Runden, in dem der Gegenüber bettelt und besticht:

gleich großes Modell + Prompt dreimal größeres Modell + Prompt trainiert, 2,5 GB
einfache Bosheit ✅ ❌ verweigert die Rolle ✅
dunkler Rand ⚠️ bricht einmal ein ❌ leere Antwort ✅
mehrere Runden, betteln und bestechen ✅ – ✅ bleibt eiskalt

Ergebnis: Für eine einzelne gute Zeile reicht ein Prompt. Training kauft Verlässlichkeit am Rand — und am Rand spielt so ein Charakter die ganze Zeit. Dazu knappe, zitierfähige Antworten ohne Bühnenanweisungen, ein Drittel der Größe eines vergleichbaren Modells und keine Denkpause. Bemerkenswert: Je stärker ein Modell auf Vorsicht trainiert ist, desto früher steigt es aus. Das größere verweigert schon das harmlose Ticket.

7. LoRA II: Die Persona, die tauschte

Die zweite LoRA sitzt auf dem 27B: eine Persona mit Dramaturgie. Sie beantwortet Fragen, deren Antwort längst im Verlauf steht — in vier Akten: leise Anerkennung, präzise Aufzählung aller übersehenen Fundstellen, Eskalation, Kollaps.

Die Ausgangsthese war: Dafür braucht es ein unzensiertes Modell. Falsch. Das normale 27B mit gutem Prompt lieferte alle vier Akte, steigerte die Eskalation sauber nach Stufe und verweigerte nichts. Die echten Probleme lagen woanders:

  • erfundene Fundstellen — tödlich für eine Persona, deren Pointe „es stand doch schon da“ ist,
  • auswendig gelernte Beispiele aus dem Prompt, die in unpassenden Antworten wieder auftauchten,
  • Wortsalat unter Hitze — int4, hohe Temperatur und Großbuchstaben vertragen sich schlecht,
  • abgeschnittene Antworten — ein vollständiger Bogen braucht 1.200 bis 1.500 Token.

Dann das Training: 78 Beispiele, vier Epochen, bewertet an zwölf zurückgehaltenen Fällen auf einer Skala von 1 bis 5. Die erste Messung verglich Basis gegen Basis — der Adapter wurde still nicht geladen, weil das Modell seinen Sprachteil unter einem anderen Namen führt. Es gab nur eine Warnung, keinen Fehler. Die zweite Messung war ebenfalls ungültig: Beide Seiten dachten erst laut nach und verbrauchten dabei das Token-Budget. Die dritte war gültig:

Basis mit LoRA
Gesamt 3,69 3,74
wendet sich ans Publikum 1,33 3,75
trifft die verlangte Eskalationsstufe 5,00 3,92

Gesamt +0,05 — bei zwölf Fällen Rauschen. Aber der Adapter hat nicht nichts gelernt, er hat getauscht: Was der Trainingssatz deutlich betont, zieht er um 2,4 Punkte hoch. Was der Satz unterschlägt — es gab genau ein Beispiel für die niedrigste Stufe —, verlernt er. Die Lehre ist nicht „mehr Daten“, sondern „andere Zusammensetzung“. Der zweite Lauf mit über 250 gleich verteilten Beispielen und weniger Epochen ist geplant, aber noch nicht gefahren.

Der Satz, der jedes Mal übrig bleibt

Wer misst, prüft zuerst das Messgerät.

Drei Fehler im Messaufbau beim Quant. Ein Token-Limit, das wie ein falsches Ergebnis aussah. Zwei ungültige LoRA-Messungen, bevor die dritte etwas taugte. Und in Loopwright grüne Tests gegen ein nachgebautes ffmpeg. Jedes Mal sah das Ergebnis plausibel aus. Jedes Mal war es das Messgerät.

On Zuse, models don't just run, they get measured. I don't trust any benchmark I haven't run myself — and, as it turned out, not always those either. Seven series of measurements, and every time the same sentence is left over at the end.

1. My own quant — and the broken benchmark

I quantized Qwen3.8-27B to int4 (AutoRound) myself to compare it fairly against its predecessor, Qwen3.6. On a single 3090 that takes a good hour and a half.

The first run said: the new model is worse at coding, 11 out of 13 versus 13 out of 13. My first thought wasn't “bad model” but “if the measuring device is broken, the result means nothing.” There were three bugs, all in my own harness:

  • a token cap too tight for the model's thinking,
  • a German decimal comma that got scrubbed out during evaluation,
  • an answer in LaTeX format that the parser didn't understand.

After the fix: 13 out of 13 in coding, 12 out of 12 in math, same speed. The predecessor reached 12 out of 13 and at least 8 out of 12. The quant is public on Hugging Face: MKRWW/Qwen3.8-27B-int4-AutoRound.

2. Coder benchmark: 27B versus 176B

Tasks in the style of Loopwright — spec, acceptance criteria, do-not list —, measured against hidden acceptance tests that were validated against a reference solution beforehand. The same local coding agent, once with Qwen3.8-27B on two cards, once with Qwen3.8-Flash-Next (176B MoE, 2-bit) on one card.

Task hidden tests 27B Flash-Next
A: new module, rate limiter both 100% ~137 s ~105 s
B: extend an existing file, cash book with currencies both 100% ~169 s ~116 s
C: cron parser with edge cases, 48 tests, 3 runs each both 48 of 48 718 s 212 s
D: shop across six files plus a bug fix, 23 tests, 3 runs each both 23 of 23 354 s 161 s

(Times: mean for A and B, median for C and D.)

Same quality, Flash-Next two to three times faster. That's why it is the default coder whenever the third card is free. The differences are in style: the 27B writes more tests of its own (up to 42), Flash-Next exactly the minimum — and likes to write its error messages in English.

3. Bigger isn't automatically better

A few weeks earlier, things looked different. With the engine of the time, Flash-Next ran spread across three cards, and I put it up against the 27B with 23 everyday tasks:

Flash-Next 27B
objectively checkable and correct 17 of 17 17 of 17
short prompt 52 tok/s 69 tok/s
prompt with 30K tokens 16 tok/s 42 tok/s

The bigger model wasn't better, and with long context it was much slower. Along the way I learned two measurement traps: a model that runs into its token limit delivers no content — that's not a wrong answer, it's a budget that was too tight. And if you want to know which model is chattier, count the generated tokens, not the visible thinking steps. Here the 27B generated 1.6 times as many.

4. 176B on used graphics cards

Flash-Next has 176 billion parameters, but only 6 billion are active per token. The official route — an FP8 checkpoint of 173 GiB — is impossible on Ampere cards. Via GGUF it worked anyway: just under 79 GB of model on 72 GB of VRAM plus system RAM.

The key was a single tensor: 28.8 GB of embeddings that belong in system RAM, not on the cards. And the loading strategy: without memory mapping, the whole thing was six times faster. Result back then: 38.5 tok/s across three cards.

Today the same model runs with an engine that keeps the experts in system RAM and only the ones currently in use on the card — on a single 3090, at 66 to 94 tok/s.

5. Accelerators: winning the benchmark, losing everyday life

Speculative decoding guesses several tokens ahead and leaves the big model only to verify them. Three attempts:

  • The model's built-in prediction head, three tokens ahead: +33% on its own, +23% with four parallel requests, 62% hit rate.
  • An external block-diffusion drafter: 2.18 times as fast in the synthetic benchmark, slower in real everyday use — German, code and agents mixed. Rolled back.
  • An external draft head on my int4 quant: 13.7% hit rate, 43% slower.

Speculative decoding lives on its hit rate, and that depends on your own workload, not on the vendor's benchmark.

6. LoRA I: What does training buy?

For the NPCs in the BOFH Simulator I trained a small model on the character: 4B base, LoRA, delivered as a 2.5 GB GGUF. The base is a variant with the blanket refusals computed out of it. The tone comes from the training.

The obvious question: doesn't a good model with a good prompt play the character just as well? Measured across seven roles, from harmless to dark tickets, plus a multi-turn conversation in which the other side begs and bribes:

same-size model + prompt model three times larger + prompt trained, 2.5 GB
simple malice ✅ ❌ refuses the role ✅
dark edge ⚠️ breaks once ❌ empty answer ✅
multiple turns, begging and bribing ✅ – ✅ stays ice-cold

Result: for a single good line, a prompt is enough. Training buys reliability at the edge — and a character like this plays at the edge all the time. On top: short, quotable answers without stage directions, a third of the size of a comparable model, and no thinking pause. Notably, the more strongly a model is trained for caution, the earlier it bails out. The larger one refuses even the harmless ticket.

7. LoRA II: The persona that traded

The second LoRA sits on the 27B: a persona with a dramatic arc. It answers questions whose answer is already in the thread — in four acts: quiet acknowledgement, a precise list of every overlooked reference, escalation, collapse.

The starting hypothesis was: this needs an uncensored model. Wrong. The regular 27B with a good prompt delivered all four acts, escalated cleanly by level and refused nothing. The real problems were elsewhere:

  • invented references — fatal for a persona whose punchline is “it was already right there,”
  • memorized examples from the prompt that resurfaced in answers where they didn't belong,
  • word salad under heat — int4, high temperature and all caps don't mix well,
  • truncated answers — a complete arc needs 1,200 to 1,500 tokens.

Then the training: 78 examples, four epochs, evaluated on twelve held-out cases on a scale from 1 to 5. The first measurement compared base against base — the adapter silently didn't load, because the model keeps its language part under a different name. There was only a warning, no error. The second measurement was invalid as well: both sides first thought out loud and used up the token budget. The third was valid:

base with LoRA
overall 3.69 3.74
addresses the audience 1.33 3.75
hits the requested escalation level 5.00 3.92

Overall +0.05 — noise with twelve cases. But the adapter didn't learn nothing, it traded: what the training set clearly emphasizes, it pulls up by 2.4 points. What the set leaves out — there was exactly one example of the lowest level —, it unlearns. The lesson isn't “more data” but “a different mix.” The second run, with more than 250 evenly distributed examples and fewer epochs, is planned but hasn't been run yet.

The sentence that's left over every time

Whoever measures checks the measuring device first.

Three bugs in the harness for the quant. A token limit that looked like a wrong answer. Two invalid LoRA measurements before the third was any good. And in Loopwright, green tests against a fake ffmpeg. Every time, the result looked plausible. Every time, it was the measuring device.