Ein 125B-Modell auf einer RTX 3060, sofern genug RAM da ist. Ich teste Strata

Strata führt Qwen3.8-Flash-Next, ein Modell mit 125 Mrd. Parametern, auf einem Rechner mit einer einzigen Grafikkarte aus. Es ist eine offene Engine unter MIT-Lizenz, veröffentlicht von einem Autor mit dem Pseudonym Niko1221 und nicht mit dem Qwen-Team verbunden. Eine Karte mit 12 GB reicht, weil der Großteil des Modells im RAM liegt: Mit einer solchen Karte braucht die getestete Variante laut Dokumentation etwa 60 GB RAM, in der Praxis 64 GB. Ich habe sie auf einem Rechner mit GeForce RTX 3060 (12 GB), einem Intel Xeon E5-2699 v4 aus dem Jahr 2016 und 121 GB RAM getestet.

Strata schrieb dort Antworten mit 43–54 Tokens pro Sekunde, am langsamsten auf Polnisch, und las lange Prompts mit etwa 800 Tokens pro Sekunde ein. Dieselbe Modelldatei schrieb in llama.cpp, mit den Experten im RAM, 16 Tokens pro Sekunde und las höchstens 226 ein. In 17 überprüfbaren Aufgaben auf Polnisch antwortete Strata ohne Thinking-Modus in 88 % der Versuche richtig, mit Thinking in 97 %. Zwei kleinere Modelle, die ich zum Vergleich auf demselben Rechner laufen ließ, gemma-4-E4B und Qwen3.6-27B, antworteten in 41–71 % der Versuche richtig und erfanden Fakten.

Wie 125 Mrd. Parameter in 12 GB passen

Qwen3.8-Flash-Next ist ein Mixture-of-Experts-Modell (MoE). Jede seiner 48 Schichten hat 512 „Experten“, also separate Netzblöcke, und der Router, ein kleines Netz am Anfang der Schicht, wählt für jedes Token 10 davon sowie einen gemeinsamen Experten aus. Laut Modellkarte arbeiten pro Token etwa 6 Mrd. Parameter, weniger als 5 % des Ganzen. Die übrigen Gewichte müssen nicht auf der Grafikkarte liegen, sie müssen nur schnell genug verfügbar sein.

Die Modellkarte zählt 125 Mrd. Parameter für das eigentliche Netz und rechnet zwei Komponenten hinzu, zusammen 180 Mrd. in den Dateien. Die erste ist eine N-Gramm-Embedding-Tabelle (51 Mrd. Parameter): fertige Zahlenvektoren für 20 Mio. häufige Token-Paare und -Tripel, die das Modell in der zweiten Schicht ausliest, statt sie zu berechnen. Die zweite ist die MTP-Schicht (Multi-Token Prediction, 4 Mrd. Parameter), die weiter unten beschrieben wird.

Strata verteilt das alles auf drei Speicherebenen:

Die Grafikkarte hält die Attention-Schichten (die Teile des Netzes, die das aktuelle Token mit dem vorherigen Text vergleichen), die Router, die gemeinsamen Experten, den Kontext-Zwischenspeicher (KV-Cache) und einen Vorrat der am häufigsten genutzten Experten. Auf meine Karte passten davon 1891 (3,9 GB), also 8 % aller Experten. Trotzdem lagen bei den Anfragen aus meinen Tests 55–69 % der vom Router gewählten Experten bereits auf der Karte; die Engine tauscht sie während der Arbeit aus, und bei der ersten Anfrage nach dem Start lagen nur 29 % davon auf der Karte.
Der RAM hält alle 24.576 Experten, in der getesteten Variante 50 GB. Einen Experten, der nicht auf der Karte liegt, berechnet die CPU, parallel zur Grafikkarte. Bei mir erledigten das 20 von 22 Kernen (einen lässt Strata dem System, auf einem läuft der Steuer-Thread), mit AVX2-Befehlen, weil dieser Prozessor kein AVX-512 hat.
Die SSD hält die N-Gramm-Tabelle (29 GB). Das Modell liest daraus einige Zeilen pro Token. Ist der RAM sehr groß (für diese Variante laut Dokumentation ab 107 GB), lädt Strata sie unter Linux dennoch in den Arbeitsspeicher, weil das nach den eigenen Messungen des Projekts das Einlesen des Prompts bei 4 Tsd. Tokens um 18 % und bei 98 Tsd. um 2 % verkürzt. So war es bei mir, deshalb belegte der Engine-Prozess 83 GB RAM.

Die Gewichte sind durch Quantisierung komprimiert, also durch Speicherung der Zahlen mit weniger Bits. Der Variantenname IQ3_S bezeichnet ein Kompressionsschema, bei dem ein Experte im Mittel etwa 3,3 Bit pro Gewicht statt 16 belegt. Die Strata-Autoren schreiben, diese Variante „schneidet in den veröffentlichten Tests genauso ab wie das volle Modell“, nennen aber nicht, um welche Tests es geht. Zahlen liefert ihre eigene Messung an 5 Tsd. Tokens Text (Code, Dokumentation, Prosa in mehreren Sprachen): IQ3_S wählt an 87,7 % der Positionen dasselbe wahrscheinlichste nächste Token wie die 8-Bit-Variante, und die Perplexity, ein Maß dafür, wie überrascht das Modell vom Text ist, steigt von 4,052 auf 4,097, also um etwa 1 %. Ein anderes Token muss den Sinn der Antwort nicht ändern, aber die Dokumentation zeigt nicht, wie oft es das tut.

Die MTP-Schicht schlägt bis zu drei folgende Tokens vor, das volle Modell prüft sie in einem Durchlauf und behält die zutreffenden. Das ist eine Form des spekulativen Decodings: Die Antwort bleibt dieselbe, sie kommt nur schneller. Auf Karten mit 12–16 GB überspringt Strata standardmäßig außerdem selten gewählte Experten, die gerade nicht auf der Karte liegen. Laut Dokumentation wählt das Modell auf einer RTX 3060 dann an 97,7 % der Positionen dasselbe wahrscheinlichste Token wie bei exakter Berechnung. Alle meine Qualitätstests liefen mit dieser Einstellung; ihren Einfluss auf die Aufgabenergebnisse habe ich nicht gemessen, sondern nur, wie viel Geschwindigkeit beide Beschleunigungen bringen (siehe unten).

Das Projekt von Dan Woods, der Qwen 397B auf einem MacBook [Polski] mit 48 GB Speicher zum Laufen brachte, las die Experten laufend von der SSD. Strata hält sie im RAM: Sie braucht davon deutlich mehr, wartet aber nicht auf die SSD.

Wie viel Speicher man braucht

Strata führt dasselbe Modell in mehreren Kompressionsstufen aus. Der Installer addiert den RAM zum Grafikspeicher, zieht 5 GB für das System ab und schlägt anhand des Ergebnisses eine Variante vor:

Schwelle des Installers (RAM + VRAM − 5 GB)	Variante	Belegt (RAM + VRAM)	Anmerkungen
32 GB	Coder IQ1_M	ca. 32 GB	die Hälfte der Experten, ausgewählt fürs Programmieren; schwächer außerhalb von Code
40 GB	IQ2_XS	39,2 GB
48 GB	IQ3_XXS	47,0 GB
64 GB	IQ3_S	54,8 GB	die langsamste und genaueste der 2–3-Bit-Varianten; hier getestet

Die Größen in der Tabelle enthalten nicht die N-Gramm-Tabelle, die standardmäßig auf der SSD bleibt. Die Schwelle liegt über dem belegten Speicher, weil die Experten allein in den RAM passen müssen: Die Dokumentation empfiehlt RAM in Höhe der Expertengröße plus etwa 10 GB, für IQ3_S also etwa 60 GB. Mit einer 12-GB-Karte bedeutet die Schwelle von 64 GB 57 GB RAM, und laut Dokumentation läuft IQ3_S mit 64 GB RAM, wenn nur wenige andere Programme geöffnet sind. Bei Rechnern mit gemeinsamem Speicher für CPU und Grafik, etwa einem Mac mit Apple-Prozessor, zählt dessen Gesamtgröße.

Ab einer Schwelle von 96 GB stehen auch 4- bis 8-Bit-Varianten von Unsloth zur Verfügung, einer Firma, die komprimierte Versionen offener Modelle veröffentlicht: von UD-IQ4_XS (94 GB Download, die Experten belegen im RAM etwa 72 GB) bis Q8_0 (188 GB Download, etwa 136 GB RAM für die Experten). Der Installer schlägt dann weiterhin IQ3_S vor, die größere Variante muss man manuell wählen; ich bin bei IQ3_S geblieben.

Die Karte muss mindestens 12 GB Speicher haben (NVIDIA ab der RTX-20-Serie, neuere Radeons, Intel Arc), und die CPU muss AVX2 unterstützen. Eine größere Karte beschleunigt das Modell, weil sie mehr Experten aufnimmt, verringert aber nicht den RAM-Bedarf.

Das Modell unterstützt nativ 262.144 Tokens Kontext. Der Installer stellt für Karten unter 14 GB 32K ein, das Limit lässt sich aber beim Start erhöhen. Ab 64K hält Strata den größeren Teil des Kontextspeichers im RAM und lässt auf der Karte nur ein 32K-Fenster. Bei den von mir eingestellten 128K belegte sie dafür 1,7 GB RAM, der Verbrauch an Grafikspeicher änderte sich nicht.

Installation unter Ubuntu

Ich habe die Installation über den Befehl strata im Terminal gewählt, die keine Administratorrechte erfordert:

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 Installationsskript prüft die SHA-256-Prüfsumme des Archivs und die Signatur des Releases und legt alles im Home-Verzeichnis ab. Der Download der Engine und des Modells samt Zusätzen (zusammen 90 GB) dauerte bei 4–9 MB/s etwa 3 Stunden 20 Minuten. Das Laden des Modells dauert etwa eine Minute. Der Server stellt eine OpenAI-kompatible API (http://127.0.0.1:8080/v1) und eine Anthropic-kompatible API (http://127.0.0.1:8080) sowie einen Chat im Browser bereit.

Beim Start warnte Strata, dass auf der Karte nur 200–450 MB freier Speicher bleiben, weil der Desktop einen Teil belegt, und schlug --vram-reserve-mib 1024 vor. Bei so voller Karte kann der Treiber GPU-Speicher in den RAM auslagern, und das Schreiben fällt dann auf wenige Tokens pro Sekunde. In meinen Tests ist das nicht passiert.

Messbedingungen

Ubuntu 26.04.1, Kernel 7.0, NVIDIA-Treiber 595.99, Strata 0.2.3 mit Engine 0.1.48 für CUDA 13, Variante IQ3_S, Kontext 128K, grafischer Desktop aktiv.
DDR4-RAM (der Xeon E5 v4 hat vier Speicherkanäle), Grafikkarte an PCIe 3.0 x16; Strata maß eine Übertragungsrate zur Karte von 10,5 GB/s.
Die Geschwindigkeiten stammen aus dem Feld timings in den Serverantworten; Strata und llama.cpp melden sie auf dieselbe Weise. Die Schreibgeschwindigkeit umfasst die aus MTP übernommenen Tokens. Den Anteil der Experten auf der Karte, die Größe ihres Speichers und die Zahl der Kerne liefert das Engine-Log.
Strata und llama.cpp zählen Tokens gleich: Derselbe Text ergab bei ihnen 7911 bzw. 7922 Tokens (der Unterschied ist das Chat-Template), sodass sich die Geschwindigkeiten in Tokens pro Sekunde vergleichen lassen.

Schreibgeschwindigkeit und woher sie kommt

Vier Prompts: eine Python-Funktion, ein Essay auf Polnisch und einer auf Englisch (je etwa 400 Wörter) und eine Liste von 30 Namen mit Begründung. Jeden Prompt habe ich zweimal geschickt, mit Temperatur 0, nach einem frischen Serverstart; in der Tabelle steht der Mittelwert beider Durchläufe in Tokens pro Sekunde:

Konfiguration	Code	Essay PL	Essay EN	Liste
Strata, Standardeinstellungen	53,8	42,9	50,3	49,2
Strata ohne MTP	40,3	42,4	42,1	42,2
Strata ohne Überspringen seltener Experten	45,5	37,8	43,2	43,1
llama.cpp, alle Experten im RAM (`--cpu-moe`)	15,6	15,6	15,6	15,7
llama.cpp, Experten von 2 Schichten auf der Karte (`--n-cpu-moe 46 -ub 2048`)	15,9	16,0	16,0	15,9

Im normalen Betrieb, mit den Standardtemperaturen (0,7 ohne Thinking, 1,0 mit Thinking), schrieb Strata ähnlich schnell: In den Qualitätstests lag der Median für Antworten mit mehr als 150 Tokens bei 52 Tokens pro Sekunde ohne Thinking und bei 49,5 mit Thinking.

MTP beschleunigt das Schreiben von Code um ein Drittel, von englischer Prosa und der Liste um 17–19 %, von polnischer Prosa dagegen kaum (1 %). Bei polnischem Text übernahm das Modell etwa 40 % der vorgeschlagenen Tokens, bei Code über 70 %, und auch das Prüfen verworfener Vorschläge kostet Zeit. Die Strata-Dokumentation verspricht das 1,6- bis 1,8-Fache; auf dieser Hardware und mit diesen Texten fiel der Gewinn kleiner aus. Das Überspringen seltener Experten brachte 13–18 %, wie in der Dokumentation angegeben.

Llama.cpp (Version b10809) lud dieselbe Datei unverändert, schrieb aber dreimal langsamer. In dieser Konfiguration nutzte es die MTP-Schicht nicht, und die Experten berechnete die CPU. Die Experten von zwei Schichten auf die Karte zu verlagern und den Prompt in Blöcken von 2048 Tokens zu verarbeiten (Parameter -ub und -b), änderte am Schreiben kaum etwas; mehr Schichten passten nicht auf die Karte.

Langer Kontext

Für die Kontextmessungen nahm ich einen zufälligen Ausschnitt der englischen Strata-Dokumentation mit einer Länge von 1 bis 115 Tsd. Tokens, jedes Mal einen anderen, damit die Engine keinen früher gespeicherten Prompt nutzen konnte. In die Mitte setzte ich einen polnischen Satz mit einem Codewort und bat um das Codewort sowie um einen Satz zum Inhalt der Dokumentation. Sechs Längen habe ich je zweimal gemessen und vier davon noch einmal mit der Bitte um eine längere Zusammenfassung, insgesamt 16 Versuche.

Das Einlesen des Prompts, also der Prefill, dauerte von 4 s bei 1 Tsd. Tokens bis 140 s bei 115 Tsd. Ab etwa 17 Tsd. Tokens lag die Geschwindigkeit bei 790–850 Tokens pro Sekunde; bei kurzen Prompts ist sie niedriger, weil ein fester Overhead dominiert. Llama.cpp las dieselbe Art von Text mit 85–91 Tokens pro Sekunde ein, bei Blöcken von 2048 Tokens mit 226. Beim Einlesen des Prompts überträgt Strata Experten über PCIe zur Karte, daher ist PCIe 3.0 hier vermutlich das langsamste Glied. Die Strata-Dokumentation nennt für eine RTX 5070 mit einem Ryzen 5 7600 etwa 1620 Tokens pro Sekunde bei einem 32K-Prompt, doppelt so viel wie bei mir. Jener Rechner hat aber auch eine andere CPU und anderen Speicher, und die Messung wurde mit einer älteren Engine-Version gemacht, sodass sich die Ursache des Unterschieds nicht bestimmen lässt.

Das Schreiben hing kaum von der Kontextlänge ab: Bei einer Zusammenfassung von 500 Tokens waren es 46 Tokens pro Sekunde bei 1,3 Tsd. Tokens Kontext und 42 bei 115 Tsd. Nur 12 der 48 Schichten des Modells sind Attention-Schichten, und auch sie lesen pro Token eine begrenzte Zahl von Kontextblöcken (laut Modellkarte bis zu 2048 Tokens). Die übrigen 36 Schichten (Gated DeltaNet) durchsuchen den Kontext nicht, sondern aktualisieren einen Zustand fester Größe.

Das Codewort nannte das Modell in 15 von 16 Versuchen, auch bei 115 Tsd. Tokens. In einem Versuch, bei 66 Tsd. Tokens, verweigerte es die Antwort: Es hielt den Satz mit dem Codewort für einen Prompt-Injection-Versuch, also für eine in den Daten versteckte Anweisung. Ein polnischer Satz in einem englischen Text ist aber leicht herauszufischen, deshalb habe ich einen schwierigeren Test ergänzt, mit fünf separaten Prompts von 9 bis 122 Tsd. Tokens Länge. Zwei englische Sätze im Stil der Dokumentation setzte ich bei einem Viertel und bei drei Vierteln des Textes ein: „nächtliche Regressionstests laufen auf der Maschine ORCA-7“ und „die Maschine ORCA-7 steht im Büro in Frankfurt“. Auf die Frage, in welcher Stadt die Maschine mit den nächtlichen Tests steht, antwortete das Modell in allen fünf Versuchen richtig.

Qualität der Antworten

Ich habe 20 Aufgaben auf Polnisch vorbereitet, weil ich das Modell in einer anderen Sprache als Englisch prüfen wollte; auf Englisch können die Ergebnisse anders ausfallen. Bei 17 Aufgaben lässt sich die Antwort automatisch prüfen: Rechenaufgaben (Multiplikation, Rabatt und Mehrwertsteuer, Tage in einem Schaltjahr zählen), Logikrätsel, Faktenfragen, eine Antwort im JSON-Format, eine Anweisung mit mehreren Einschränkungen zugleich, eine Frage nach einem nicht existierenden Roman von Bolesław Prus (einem polnischen Schriftsteller des 19. Jahrhunderts, Autor von „Lalka“ (Die Puppe)) sowie drei Python-Funktionen, die ich mit Tests ausführte. Die schwierigste davon schreibt Zahlen von 0 bis 999.999 in polnischen Wörtern aus; polnische Zahlwörter ändern je nach Zahl ihre Form („dwa tysiące“ (zweitausend), „pięć tysięcy“ (fünftausend)), und die Aufgabe verlangte „tysiąc“ (tausend) statt „jeden tysiąc“ (eintausend). Drei Aufgaben (technische Erklärung, E-Mail an einen Kunden, Übersetzung von Redewendungen) habe ich durch Lesen der Antworten bewertet.

Strata verwendet standardmäßig die Temperaturen aus der Modellkarte, daher unterscheiden sich die Antworten zwischen den Durchläufen. Den Aufgabensatz ohne Thinking habe ich dreimal durchlaufen lassen, mit Thinking zweimal. Die Vergleichsmodelle habe ich über llama.cpp in den Varianten Q4_K_M (etwa 4,8 Bit pro Gewicht) mit den Temperaturen aus ihren Modellkarten ausgeführt: gemma-4-E4B dreimal ohne und zweimal mit Thinking, Qwen3.6-27B zweimal und nur ohne Thinking, weil ein Durchlauf mit Thinking bei seiner Geschwindigkeit nach meiner Schätzung über eine Stunde gedauert hätte.

Modell und Modus	Richtige Antworten in 17 Aufgaben	Dauer des ganzen Aufgabensatzes (20 Aufgaben)
Strata, Qwen3.8-Flash-Next, ohne Thinking (3 Durchläufe)	45 von 51 (88 %)	83–96 s
Strata, Qwen3.8-Flash-Next, mit Thinking (2 Durchläufe)	33 von 34 (97 %)	412–534 s
gemma-4-E4B, ohne Thinking (3 Durchläufe)	21 von 51 (41 %)	78–88 s
gemma-4-E4B, mit Thinking (2 Durchläufe)	21 von 34 (62 %)	215–216 s
Qwen3.6-27B, ohne Thinking (2 Durchläufe)	24 von 34 (71 %)	658–690 s

Ohne Thinking irrte sich Strata in vier Aufgaben, am häufigsten in zweien davon. Das Rätsel über drei Personen, von denen ein Teil immer lügt, löste sie in einem von drei Versuchen und antwortete jedes Mal in weniger als einer Sekunde. Die Funktion, die Zahlen in Worten ausschreibt, bestand die Tests in zwei von drei Versuchen nicht: Einmal schrieb sie „jeden tysiąc“, obwohl die Aufgabe ausdrücklich „tysiąc“ verlangte, einmal verlor sie das Wort „tysięcy“ (Genitiv Plural von „tausend“). In einem Durchlauf lag sie auch beim Ergebnis einer Multiplikation daneben (40.701.304 statt 40.701.104), und die Funktion, die die Schreibweise „1h 30m 15s“ in Sekunden umwandelt, wies Großbuchstaben zurück, obwohl die Aufgabe verlangte, sie zu akzeptieren. Mit Thinking war der einzige Fehler wieder „jeden tysiąc“. Auf die Frage nach Prus’ „Szklany ogród“ (Der gläserne Garten) antwortete das Modell in allen fünf Versuchen, dass es einen solchen Roman nicht gibt.

Thinking kostet viel Zeit. Der Aufgabensatz dauerte fünfmal so lange, und am meisten Zeit brauchten einfache Programmieraufgaben: Die erwähnte Funktion für die Zeitdauer entstand in 101 s und mit 4712 Tokens statt in 6 s, bei gleichem Testergebnis.

Gemma-4-E4B (5 GB) passt vollständig auf die Karte und schreibt 75 Tokens pro Sekunde, anderthalbmal so schnell wie Strata. Ohne Thinking antwortete es in 21 von 51 Versuchen richtig, mit Thinking in 21 von 34. In allen fünf Durchläufen irrte es sich bei der Multiplikation, beim Zählen von Buchstaben und bei der Frage nach dem System, auf dem Linux entstanden ist, und jedes Mal erfand es eine Handlung für den nicht existierenden Roman von Prus, mit immer wieder anderer Hauptfigur. Im ersten Durchlauf ohne Thinking schnitt das Limit von 1200 Tokens zwei seiner Programmierantworten ab, weil das Modell dem Code eigene Tests hinzufügte.

Qwen3.6-27B (17 GB) ist ein dichtes Modell, berechnet also bei jedem Token alle Gewichte. Auf einer 12-GB-Karte bleibt ein Teil davon im RAM, deshalb schrieb es 5 Tokens pro Sekunde, und der Aufgabensatz dauerte 11 Minuten. Es antwortete in 24 von 34 Versuchen richtig. In beiden Durchläufen lag es beim Erscheinungsjahr von „Lalka“ falsch, ebenso beim Lügner-Rätsel und bei der Funktion für Zahlen in Worten. Auf die Frage nach „Szklany ogród“ antwortete es beide Male, dass Prus diesen Roman nicht geschrieben habe, fügte aber erfundene Fakten hinzu und schrieb Prus etwa „W pustyni i w puszczy“ (Durch Wüste und Wildnis) zu, einen Roman von Henryk Sienkiewicz.

Der Hersteller nennt für das volle Modell Qwen3.8-Flash-Next unter anderem 91,7 in GPQA Diamond und 62,5 in SWE-bench Pro; das sind Qwens Ergebnisse für das unkomprimierte Modell, die mein Aufgabensatz nicht überprüft.

Claude Code und andere Agenten

Der Befehl strata connect gibt die Konfiguration für OpenCode, Codex CLI, Claude Code, Hermes Agent (einen Open-Source-Agenten von Nous Research), OpenClaw und einige weitere Tools aus und speichert sie. Mit der Option --check sendet er eine Frage und einen Tool-Aufruf (Tool Calling, also die Bitte des Modells, eine Funktion auszuführen) so, wie es die jeweilige Anwendung tut. Für Claude Code und Hermes Agent bestanden beide Prüfungen in 3–4 Sekunden.

Eine echte Aufgabe gab ich Claude Code (Version 2.1.310, im Modus --bare, also ohne Plugins und MCP-Server): ein kleines Python-Projekt mit einem Fehler beim Wörterzählen, einer nicht implementierten Funktion top_words und sechs Tests, von denen fünf fehlschlugen. Der Agent führte die Tests aus, behob den Fehler, schrieb die Funktion und führte die Tests erneut aus. Das dauerte 19 Schritte und 133 Sekunden, alle Tests liefen durch, und die Testdatei blieb unangetastet. Im Code blieb eine Inkonsistenz: Eine Hilfsfunktion ist mit einer Liste als Rückgabetyp annotiert, gibt aber einen Generator zurück. Das ist ein einzelner Versuch mit einer einfachen Aufgabe, keine Bewertung der Arbeit mit einem größeren Repository.

Der erste Schritt schickte 4,6 Tsd. Tokens System-Prompt und Tool-Beschreibungen, die Strata in 6,3 s einlas. In den folgenden Schritten waren 95–99 % des Prompts bereits gespeichert, sodass die Engine nur den angehängten Teil in 0,3–1,1 s einlas, obwohl die Unterhaltung auf 8,3 Tsd. Tokens wuchs. Strata hält die eingelesenen Prompts mehrerer Unterhaltungen im RAM (bei mir bis zu 8 GB), bearbeitet sie aber nacheinander: Standardmäßig beantwortet sie jeweils nur eine Anfrage. Der vollständige Prompt von Claude Code ohne den Modus --bare hat laut Strata-Dokumentation 15,6 Tsd. Tokens, der von Hermes Agent 12,9 Tsd., deshalb lohnt es sich, für die Arbeit mit Agenten den Kontext über die standardmäßigen 32K hinaus zu erhöhen.

Wann es sich lohnt

Einen Teil der Arbeit vollständig lokal erledigen zu können, mit einem Modell, das kleiner ist als die führenden Cloud-Modelle, ist verlockend, und dieser Test zeigt, was man dafür braucht. Gemma-4-E4B, das komplett auf die Karte passt, antwortete am schnellsten, irrte sich aber in mehr als der Hälfte der Versuche und erfand Fakten. Qwen3.8-Flash-Next über Strata antwortete ohne Thinking in 88 % der Versuche richtig, bei 43–54 Tokens pro Sekunde, mit Thinking in 97 %, wobei der Aufgabensatz dann allerdings fünfmal so lange dauerte. Dafür braucht es etwa 60 GB RAM und fast die ganze Grafikkarte. Qwen3.6-27B, ein dichtes Modell, das nicht auf die Karte passt, schnitt schlechter ab als Strata und war zehnmal langsamer: In diesem Vergleich entschied über die Geschwindigkeit, wie viele Gewichte pro Token berechnet werden müssen, nicht die Größe des ganzen Modells.

Auf einem Rechner mit viel RAM ist ein lokales Modell also sinnvoll bei Daten, die ich nicht in die Cloud schicken will, bei der Informationssuche in langen Dokumenten (115 Tsd. Tokens liest es in etwa 2,5 Minuten ein), bei einfacheren Programmieraufgaben und bei Agenten, die in den einzelnen Schritten nur wenig an die Unterhaltung anhängen. Weniger gut geeignet ist es, wenn mehrere Personen den Server gleichzeitig nutzen, wenn die Grafikkarte für etwas anderes gebraucht wird oder wenn jede Aufgabe Thinking erfordert. Token-Gebühren fallen nicht an, aber der Rechner verbraucht unter Last Strom: Allein die Grafikkarte zog beim Schreiben etwa 140 W, die Leistungsaufnahme des ganzen Rechners habe ich nicht gemessen.

Quellen

Strata, Repository und Dokumentation, Niko1221, Version 0.2.3, Engine 0.1.48: README, docs/MODELS.md, docs/DETAILS.md, docs/QUANTS.md, docs/HOW_IT_WORKS.md.
Qwen3.8-Flash-Next, Modellkarte, Qwen.
llama.cpp, ggml-org, Version b10809.
Hermes Agent, Nous Research.