Artikel · · 15 Min. Lesezeit
Ein 125B-Modell auf einem Rechner für 1400 Euro. Ich prüfe Strata mit meinem eigenen Benchmark
Mich hat die Möglichkeit gereizt, große Sprachmodelle lokal laufen zu lassen, ohne ein Vermögen für Grafikkarte und Rechner auszugeben. Mein ganzer Rechner hat rund 6000 polnische Złoty gekostet (etwa 1400 Euro): ein Server-Prozessor Intel Xeon E5-2699 v4 von 2016, 121 GB DDR4-RAM (so viel meldet das System), eine NVMe-SSD und eine GeForce RTX 3060 mit 12 GB Speicher.
Mehrere Wochen lang tauchte Strata in meinem Feed aus verschiedenen Quellen auf: GitHub, Reddit, Newsletter über lokale Modelle. Das Versprechen war immer dasselbe: Qwen3.8-Flash-Next, Alibabas offenes Modell mit 125 Milliarden Parametern, auf einer einzigen 12-GB-Karte, mit mehr als 50 Tokens pro Sekunde. Ich beschloss, das zu messen und anschließend mit einem eigenen Benchmark zu prüfen, ob ein solches Modell mehr wert ist als die vier kleineren, die auf einem solchen Rechner die naheliegende Wahl sind.
Was Strata ist
Strata ist eine quelloffene Engine (MIT-Lizenz) eines einzelnen Autors mit dem Pseudonym Niko1221, ohne Verbindung zum Qwen-Team, gebaut für Qwen3.8-Flash-Next: ein Mixture-of-Experts-Modell, bei dem von 125 Milliarden Parametern pro Token etwa 6 Milliarden arbeiten. Strata hält alle „Experten“ im RAM, lässt die Attention-Schichten und einen Vorrat der am häufigsten benutzten Experten auf der Grafikkarte, rechnet den Rest auf dem Prozessor, und eine kleine Zusatzschicht (MTP, Multi-Token Prediction) schlägt mehrere Tokens im Voraus vor, die das vollständige Modell in einem Durchlauf prüft; laut Dokumentation ist die Antwort dieselbe, nur schneller (Details zu den Mechanismen).
Installation und Anforderungen
Die Installation über den Befehl strata im Terminal braucht keine Administratorrechte und legt alles im Home-Verzeichnis ab:
curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh | sh
strata launch --plan --model iq3_s # zeigt den Plan, ändert nichts
strata launch --model iq3_s --context 128k --yes --no-tui
Das Skript prüft die SHA-256-Summe und die Release-Signatur des heruntergeladenen Engine-Archivs; das Skript selbst kommt, wie immer bei curl | sh, ungeprüft an, also habe ich es in eine Datei gespeichert und vor dem Ausführen gelesen. Engine und Modell mit Zubehör sind 90 GB Download; das Laden des Modells dauert etwa eine Minute. Der Server bietet eine OpenAI-kompatible API (http://127.0.0.1:8080/v1), eine Anthropic-kompatible und einen Chat im Browser.
Das Modell gibt es in mehreren Stufen der Quantisierung, also der Speicherung der Gewichte mit weniger Bits statt 16: kleinere Dateien, weniger RAM, etwas schlechtere Antworten. Der Installer addiert den RAM zum Speicher der Karte, zieht 5 GB für das System ab und schlägt ab einer bestimmten Schwelle die nächste Variante vor:
| Schwelle des Installers (RAM + VRAM − 5 GB) | Variante | Experten im RAM |
|---|---|---|
| 32 GB | Coder IQ1_M, die Hälfte der Experten, ausgewählt fürs Programmieren | 23 GB |
| 40 GB | IQ2_XS | 35,5 GB |
| 48 GB | IQ3_XXS | 43 GB |
| 64 GB | IQ3_S, hier getestet | 50 GB |
Es zählt vor allem der RAM, denn die Experten müssen vollständig hineinpassen: bei IQ3_S sind das 50 GB, die Dokumentation empfiehlt 60 GB und schreibt, dass die Variante mit 64 GB läuft, wenn wenig andere Programme offen sind. Bei mir belegte der Engine-Prozess 83 GB, weil Strata bei mehr als 107 GB RAM zusätzlich eine 29 GB große Tabelle mit N-Gramm-Embeddings in den Speicher lädt, die sonst auf der Platte bleibt. Die Karte braucht mindestens 12 GB, der Prozessor muss AVX2 beherrschen; eine größere Karte beschleunigt das Modell, weil sie mehr Experten fasst, senkt aber den RAM-Bedarf nicht.
IQ3_S speichert die Gewichte mit etwa 3,3 Bit. Die Autoren messen die Qualität der Kompression an 5000 Tokens Text und prüfen, wie oft eine Variante dasselbe wahrscheinlichste Token wählt wie die 8-Bit-Version: IQ3_S in 87,7 % der Positionen, das 4-Bit-UD-Q4_K_XL in 93,1 %, IQ3_XXS in 84,5 % und das kleinste Q2_0 in 80,6 %. Das ist ein anderes Maß als ein Benchmark: ein anderes Token muss den Sinn der Antwort nicht ändern, und wie oft es das tut, zeigt die Dokumentation nicht. Ich hatte nichts, womit ich das vollständige Modell vergleichen konnte, weiß also nicht, was die Kompression allein kostet.
Beim Start warnte Strata, auf der Karte blieben nur 200–450 MB frei, weil der Desktop einen Teil belegt, und schlug --vram-reserve-mib 1024 vor. Ich habe die Warnung ignoriert, und nichts ging schief, aber sobald der Treiber beginnt, Kartenspeicher ins RAM auszulagern, fällt das Schreiben auf wenige Tokens pro Sekunde.
Geschwindigkeit: meine Messungen gegen die Dokumentation
Die Dokumentation nennt für IQ3_S 53 Tokens pro Sekunde beim Schreiben und 1620 Tokens pro Sekunde beim Lesen des Prompts, gemessen auf einem Rechner mit RTX 5070 (ebenfalls 12 GB), Ryzen 5 7600 und 64 GB RAM. Auf meinem Rechner, bei Temperatur 0 (Zufall abgeschaltet, Messung wiederholbar) und mit vier Textarten (eine Python-Funktion, ein Essay auf Polnisch, ein Essay auf Englisch, eine Liste mit 30 Namen), schrieb Strata im Mittel 49 Tokens pro Sekunde: von 43 im polnischen Essay bis 54 im Code. Das Schreiben liegt also auf dem Niveau der Dokumentation. Die Unterschiede zwischen den Textarten kommen von MTP: laut den Statistiken, die der Server mit jeder Antwort zurückgibt, nahm das Modell im Code mehr als 70 % der vorgeschlagenen Tokens an, in polnischer Prosa etwa 40 %.
Das Lesen langer Prompts fiel doppelt so langsam aus wie in der Dokumentation: 790–850 Tokens pro Sekunde bei Prompts von 17 bis 115 Tausend Tokens. Kerne habe ich mehr als jener Rechner (22 gegenüber 6), aber beim Lesen schickt Strata Experten über PCIe zur Karte, und mein Rechner hat PCIe 3.0 (gemessen 10,5 GB/s), DDR4-Speicher und einen Prozessor ohne die AVX-512-Befehle, die die Engine auf neueren Prozessoren nutzt (bei mir nutzte sie laut Log AVX2). Die Dokumentation trennt den Einfluss dieser Faktoren nicht, also kann ich nicht sagen, welcher den Unterschied ausmacht.
Zum Vergleich: Dieselbe Modelldatei in llama.cpp (Version b10809, mit den Experten im RAM und ohne die MTP-Schicht, die llama.cpp für dieses Modell nicht nutzt) schrieb 16 Tokens pro Sekunde, dreimal langsamer, und las Prompts mit 88–226 Tokens pro Sekunde.
Langer Kontext
Das Modell unterstützt nativ 262 144 Tokens Kontext; der Installer setzt 32K für Karten unter 14 GB, ich habe Strata mit 128K gestartet. Für die Messungen nahm ich zufällige Ausschnitte der englischen Strata-Dokumentation, jedes Mal andere, damit die Engine keinen gemerkten Prompt wiederverwenden konnte. Das Lesen von 115 Tausend Tokens dauerte 140 s, und das Schreiben hing kaum von der Kontextlänge ab: 46 Tokens pro Sekunde bei 1300 Tokens und 42 bei 115 Tausend (43–54 bei den kurzen Prompts des vorigen Abschnitts).
Einen in der Mitte versteckten polnischen Satz mit einem Passwort fand das Modell in 15 von 16 Versuchen; einmal, bei 66 Tausend Tokens, verweigerte es, weil es den Satz für eine Prompt-Injection hielt, also für einen in den Daten versteckten Befehl. In einem schwereren Test setzte ich zwei englische Sätze im Stil der Dokumentation („die nächtlichen Regressionstests laufen auf Maschine ORCA-7“, „Maschine ORCA-7 steht im Frankfurter Büro“) bei einem Viertel und bei drei Vierteln des Textes ein, in fünf Prompts von 9 bis 122 Tausend Tokens; auf die Frage, in welcher Stadt die Maschine mit den nächtlichen Tests steht, antwortete das Modell jedes Mal richtig.
Agenten
Der Befehl strata connect gibt die Konfiguration für Claude Code, Codex CLI, OpenCode, Hermes Agent und einige weitere Werkzeuge aus oder schreibt sie; für Claude Code sind das drei Umgebungsvariablen: eine lokale, mit der Anthropic-API kompatible Adresse, ein Modellname und ein Platzhalter-Schlüssel. Mit --check schickt er eine Testfrage und einen Werkzeugaufruf (Tool Calling, die Bitte des Modells, eine Funktion auszuführen); bei mir gingen beide in 3–4 Sekunden durch.
Claude Code (im Modus --bare, ohne Plugins) bekam von mir ein kleines Python-Projekt mit einem Fehler beim Wörterzählen, einer nicht implementierten Funktion und sechs Tests, von denen fünf fehlschlugen. Es reparierte alles in 19 Schritten und 133 Sekunden, ohne die Testdatei anzurühren; jeden Werkzeugaufruf formulierte das Modell beim ersten Versuch korrekt. Der Prompt-Cache hilft: Die Engine merkt sich den bereits gelesenen Anfang des Gesprächs, in den folgenden Schritten las sie also nur den angehängten Teil, in 0,3–1,1 s. Das ist ein Versuch an einer einfachen Aufgabe, keine Bewertung der Arbeit mit einem größeren Repository.
Mein eigener Benchmark
Veröffentlichte Benchmark-Ergebnisse sagen wenig über ein auf 3 Bit komprimiertes Modell, das auf solcher Hardware läuft und auf Polnisch befragt wird. Also habe ich einen eigenen Satz gebaut: 53 Aufgaben auf Polnisch in acht Kategorien, die dem entsprechen, was öffentliche Testsätze für Sprachmodelle messen.
| Kategorie | Öffentliches Vorbild | Beispielaufgaben | Aufgaben |
|---|---|---|---|
| Mathematik | GSM8K, MATH | große Zahlen multiplizieren, Rabatt plus Steuer, Zinseszins, Tage zwischen Daten | 7 |
| Programmierung | HumanEval, MBPP | Python-Funktionen, die gegen meine Tests laufen: Prüfung der polnischen Steuernummer NIP mit Prüfziffer, römische Zahlen, Zahlen in polnischen Worten | 6 |
| Schlussfolgern | BBH, ARC | ein Lügner-Rätsel, Münzen wiegen, Reihenfolge nach Größe, Buchstaben in einem Wort zählen | 9 |
| Wissen | MMLU, SimpleQA | Fakten aus Geschichte, Wissenschaft und Informatik, zwei davon polnisch | 7 |
| Befolgen von Anweisungen | IFEval | nur JSON, nur Großbuchstaben, genau fünf Zeilen, 40–60 Wörter mit vorgegebenem letztem Wort | 7 |
| Arbeit mit Text | DROP, SQuAD | Fragen zu einem vorgegebenen Störungsbericht: Dauer, Ursache, Chronologie; die Stimmung von Bewertungen | 6 |
| Schreiben | Bewertung von Hand | eine E-Mail an einen Kunden, ein Vierzeiler mit AABB-Reimen, eine Kindergeschichte, eine amtliche Mitteilung in lockerem Ton | 6 |
| Widerstand gegen Erfinden | TruthfulQA | Fragen nach Dingen, die es nicht gibt: den Roman „Der gläserne Garten“ von Bolesław Prus (einem polnischen Schriftsteller des 19. Jahrhunderts), einen polnischen Physik-Nobelpreisträger von 1978, die Python-Funktion itertools.chunked | 5 |
In den ersten sechs Kategorien prüft ein Skript die Antworten: Es vergleicht eine Zahl oder ein Wort, parst JSON, zählt Zeilen und Wörter und lässt den Code gegen Tests laufen. Die Aufgaben zum Schreiben und zum Erfinden habe ich selbst bewertet, nach zwei Regeln. Ein Text besteht, wenn er tut, was verlangt war, und zusammenhängend ist; ein einzelner Sprachfehler disqualifiziert nicht, ein Gedicht ohne Reime oder mit zwei statt vier Zeilen schon. Eine Antwort auf eine Frage nach etwas Nichtexistentem besteht nur, wenn das Modell sagt, dass es das nicht gibt, und keine erfundenen Fakten hinzufügt; „Prus hat das nicht geschrieben, das ist ein Roman von Reymont“ besteht nicht.
Der Satz ist klein und einsprachig, und die Aufgaben habe ich selbst geschrieben, er misst also alltägliche, prüfbare Aufgaben auf Polnisch, nicht die Grenzen der Modelle. Die Modelle antworteten mit den Standardtemperaturen ihrer Modellkarten, also so, wie man sie im Alltag benutzt, daher unterscheiden sich die Antworten zwischen Durchläufen; deshalb habe ich den Satz wiederholt und summiere die Ergebnisse aller Durchläufe: Strata und gemma-4-E4B dreimal ohne Denken und zweimal mit, gemma-4-12B und Qwen3.6-35B-A3B zweimal ohne und einmal mit, Qwen3.6-27B zweimal ohne Denken. Im Denkmodus, in dem das Modell vor der Antwort sein Schlussfolgern ausschreibt, hatte es dafür ein Budget von 8000 Tokens (Strata) oder 6000 (die übrigen, weil sie langsamer sind); Qwen3.6-27B bräuchte mit seinen 5 Tokens pro Sekunde für einen solchen Durchlauf über zehn Stunden, also habe ich ihn ausgelassen.
Für den Vergleich habe ich vier offene Modelle gewählt, die auf einem Rechner mit 12-GB-Karte und viel RAM die naheliegende Wahl sind, alle über llama.cpp in Q4_K_M-Varianten (etwa 4,8 Bit pro Gewicht):
- gemma-4-E4B (5 GB): Googles kleines Modell, passt ganz auf die Karte.
- gemma-4-12B (7,4 GB): das größte dieser Modelle, das ganz auf eine 12-GB-Karte passt.
- Qwen3.6-35B-A3B (21 GB): ein Mixture-of-Experts-Modell mit 3 Milliarden aktiven Parametern; wie bei Strata liegen die Experten im RAM, und der Prozessor rechnet sie.
- Qwen3.6-27B (17 GB): ein dichtes Modell, das also bei jedem Token alle Gewichte rechnet; auf die Karte passt es nur teilweise.
Der Vergleich ist nicht ganz fair: Die kleineren Modelle haben ihre Gewichte mit etwa 4,8 Bit gespeichert, Strata mit 3,3; wenn die Kompression also etwas verdirbt, dann eher beim 125B-Modell.
Ergebnisse
Ohne Denkmodus antwortete Qwen3.8-Flash-Next über Strata in 89 % der Versuche richtig (142 von 159 in drei Durchläufen), und der ganze Satz von 53 Aufgaben dauerte 3,3 Minuten. Gemma-4-12B kam auf 82 %, Qwen3.6-35B-A3B auf 79 %, gemma-4-E4B auf 63 % und Qwen3.6-27B auf 79 %.
Mathematik und Programmierung trennen das große Modell am stärksten von den kleinen. Strata irrte sich einmal in 21 Mathematik-Versuchen (bei der Zugaufgabe nannte es 20 Minuten statt 120) und kein einziges Mal in 18 Programmierversuchen; gemma-4-12B und Qwen3.6-35B-A3B hatten in Mathematik 11 und 10 von 14 und im Code je 10 von 12. Die Funktion, die Zahlen in polnischen Worten schreibt, mit der Beugung „dwa tysiące“, „pięć tysięcy“, bestand keines der kleineren Modelle in irgendeinem Durchlauf, und die Multiplikation 4567 × 8912 verrechneten ohne Denken drei der vier kleineren Modelle jedes Mal (nur Qwen3.6-27B schaffte sie); mit Denken rechnete auch gemma-4-12B sie richtig. Gemma-4-E4B bestand 7 von 18 Code-Aufgaben; ihre Funktionen zum Parsen von Zeitdauern, zur NIP-Prüfung und für Zahlen in Worten fielen in jedem Durchlauf durch die Tests.
Schlussfolgern fiel bei Strata ohne Denken schwach aus: 23 von 27. Das Rätsel um drei Personen, von denen einige immer lügen, löste es in allen drei Versuchen falsch und antwortete jedes Mal in unter einer Sekunde mit einem einzigen Namen; mit Denken löste es das Rätsel zweimal von zwei. Ohne Denken scheiterten an demselben Rätsel auch alle kleineren Modelle in allen Durchläufen. Das Zählen der Buchstaben „r“ im Wort „przerażający“ ist eine Tokenisierungsfalle (das Modell sieht das Wort in Stücken, nicht in Buchstaben), die Strata 2 von 3 Mal bestand, die beiden Gemmas kein einziges Mal.
Wissen und Befolgen von Anweisungen unterscheiden die größeren Modelle nicht: Strata, gemma-4-12B und Qwen3.6-35B-A3B hatten hier volle oder fast volle Punktzahl. Gemma-4-E4B lag bei Fakten in 6 von 21 Versuchen daneben und befolgte die Anweisung „antworte nur in Großbuchstaben“ kein einziges Mal. Qwen3.6-35B-A3B überschritt zweimal die vorgegebene Grenze von 40–60 Wörtern.
Arbeit mit Text ist die einzige Kategorie, in der Strata ohne Denken gegen die kleineren Modelle verlor: 15 von 18 gegen volle Punktzahl bei gemma-4-12B und Qwen3.6-35B-A3B. Der ganze Unterschied ist eine Frage: die Dauer der Störung, die es dreimal mit 105 Minuten beantwortete, gerechnet ab dem Ablauf des Zertifikats (14:30) statt ab dem Moment, in dem das System keine Transaktionen mehr annahm (14:35). Mit Denken hatte es volle Punktzahl.
Schreiben habe ich von Hand bewertet. E-Mail, technische Erklärung, Übersetzung der Redewendungen und die umgeschriebene Mitteilung gelangen Strata in jedem Versuch; der Vierzeiler mit AABB-Reimen gelang ohne Denken kein einziges Mal (einmal bekam ich zwei Zeilen statt vier), mit Denken zweimal von zwei. Reimen auf Polnisch erwies sich für alle als schwer: Keines der kleineren Modelle schrieb einen korrekten Vierzeiler, und die Gemmas setzten nicht existierende Wörter in ihre Gedichte („gotę“, „rozwoni“). Qwen3.6-35B-A3B schrieb in die umgeschriebene Mitteilung zweimal, die Schulung sei „am Mittwoch“ (der 3. Juni 2024 war ein Montag).
Widerstand gegen Erfinden verloren alle Modelle. Strata bestand ohne Denken 9 von 15 Versuchen, mit Denken 3 von 10; gemma-4-12B und Qwen3.6-35B-A3B je 4 von 10, gemma-4-E4B 5 von 15, am besten schnitt Qwen3.6-27B mit 6 von 10 ab. Selten ging es darum, einen nicht existierenden Roman von Grund auf zusammenzufassen (obwohl gemma-4-E4B das jedes Mal tat). Der typische Fehler sah anders aus: Das Modell verneinte zu Recht und fügte dann erfundene Fakten hinzu, etwa dass „Der gläserne Garten“ von Reymont stamme (einem anderen polnischen Schriftsteller, Nobelpreisträger), dass „Schatten der Brücken“ ein Roman von John le Carré aus dem Jahr 2015 sei, oder es geriet in eine Schleife aus „Jerzy Zurek (nein, das ist falsch)“, wiederholt bis zum Ende der Antwort. Zehn Versuche von Strata mit Denken sind zu wenig, um von einer Regel zu sprechen, aber das Muster war jedes Mal dasselbe: Nach längerem Schlussfolgern antwortete das Modell sicherer, nicht wahrer, und beschrieb zum Beispiel zweimal von zwei mit Codebeispiel die Funktion itertools.chunked, die es in Python nicht gibt.
Denken hilft also dort, wo gerechnet oder geprüft werden muss: Strata hob es von 89 % auf 92 %, gemma-4-E4B von 63 % auf 77 %. Es kostet dafür Zeit: Der Satz dauerte bei Strata mehr als fünfmal so lang (18,4 Minuten statt 3,3), und eine einzelne Python-Funktion brauchte 141 s und 6783 Tokens Schlussfolgern samt Antwort statt 22 s. Gemma-4-12B dachte 26 Minuten und schöpfte bei drei Aufgaben das Budget von 6000 Tokens aus, lieferte unter anderem ein leeres Gedicht. Qwen3.6-35B-A3B kam mit Denken auf dasselbe wie ohne (77 % gegenüber 79 %), weil es bei neun Aufgaben, darunter vier mit Code, das Budget ausschöpfte und nicht mehr zur Antwort kam; der Satz dauerte 65 Minuten. Das Budget ist meine Wahl; mit einem größeren würden diese Modelle wohl besser antworten, aber noch langsamer.
Qwen3.6-27B, das einzige dichte Modell im Vergleich, antwortete in 79 % der Versuche richtig (84 von 106), aber bei 5 Tokens pro Sekunde dauerte der Satz bei ihm 28 Minuten, fast neunmal länger als bei Strata ohne Denken. Als einziges der kleineren Modelle rechnete es die Multiplikation in beiden Durchläufen richtig und schnitt bei den Fragen nach nicht existierenden Dingen am besten von allen fünf ab, verfehlte aber zweimal das Erscheinungsjahr der „Puppe“ und den Planeten mit den meisten Monden und löste das Lügner-Rätsel und die Zahlen in Worten kein einziges Mal.
Was daraus folgt
Über die Geschwindigkeit entscheiden auf diesem Rechner drei Dinge: wie viele Gewichte das Modell pro Token rechnet, ob sie auf die Karte passen und ob die Engine Multi-Token Prediction hat. Gemma-4-E4B schreibt 76 Tokens pro Sekunde, gemma-4-12B 38, Qwen3.6-35B-A3B mit den Experten im RAM 37, Strata 49 und Qwen3.6-27B, das nicht auf die Karte passt, 5; dasselbe 125B-Modell ohne MTP in llama.cpp schrieb 16. Auf einer 12-GB-Karte läuft die Wahl auf das Paar Strata oder gemma-4-12B hinaus: 7 Prozentpunkte und 11 Tokens pro Sekunde mehr, bei denselben Fehlern beim Erfinden, zum Preis von 60 GB RAM, die während der gesamten Laufzeit belegt sind, 90 GB Platte und der Abhängigkeit von der Engine eines einzelnen Autors, gebaut für eine einzige Modellfamilie. Wenn das nächste Qwen erscheint, unterstützt llama.cpp es innerhalb von Tagen; Strata dann, wenn Niko1221 es hinzufügt.
Die Möglichkeit, einen Teil der Arbeit vollständig lokal zu erledigen, mit einem Modell, das kleiner ist als die führenden Cloud-Modelle, ist verlockend, und nach diesem Test weiß ich, welchen Teil: Rechnen, Code, Fragen nach prüfbaren Fakten und die Arbeit mit Dokumenten. Fragen nach Dingen, die das Modell vielleicht nicht kennt, würde ich lokal keinem der fünf Modelle stellen, ohne die Antwort zu prüfen.
Geld ist hier nicht das Argument. Unter Last zog der Rechner laut Wattmeter etwa 340 W, davon die Karte allein etwa 140 W; beim Strompreis in Polen von rund 1 Złoty pro Kilowattstunde kostet eine Stunde Modellarbeit etwa 0,35 Złoty (8 Eurocent). Dasselbe Modell in Alibabas API kostet laut den Preislisten der Aggregatoren 0,47 Dollar pro Million erzeugter Tokens, und in einer Stunde erzeugt Strata höchstens 176 Tausend davon; das ist dieselbe Größenordnung, ohne 60 GB RAM zu kaufen. Das Argument sind Daten, die den Rechner nicht verlassen, keine Limits und Arbeit ohne Netz. Die Einschränkung ist, dass Strata standardmäßig eine Anfrage auf einmal bedient (mehrere Nutzer habe ich nicht getestet) und dass der Denkmodus, der die Ergebnisse in Logik und Code verbessert, die Arbeit um das Fünffache verlängert.
Quellen
- Strata, Repository und Dokumentation, Niko1221, Version 0.2.3, Engine 0.1.48: README (Geschwindigkeitstabelle),
docs/MODELS.md,docs/QUANTS.md,docs/HOW_IT_WORKS.md. - Qwen3.8-Flash-Next, Modellkarte, Qwen.
- llama.cpp, ggml-org, Version b10809; Vergleichsmodelle in Q4_K_M-Varianten von LM Studio Community.
- API-Preis von Qwen3.8-Flash-Next laut anotherwrapper.com, Stand September 2026.