Christoph Kind LogoCHRISTOPH KIND
Qwen3.8-27B gegen die Cloud: Was lokale Coding-Modelle 2026 wirklich leisten

Qwen3.8-27B gegen die Cloud: Was lokale Coding-Modelle 2026 wirklich leisten

Qwen3.8-27B gegen die Cloud: Was lokale Coding-Modelle 2026 wirklich leisten

Artikel-Übersicht

Der August 2026 war ein guter Monat für alle, die ihre Modelle lieber selbst betreiben. Alibaba hat innerhalb von zwei Wochen erst sein Spitzenmodell Qwen3.8-Max vorgestellt, dann dessen Gewichte veröffentlicht und schließlich das kleine Geschwistermodell Qwen3.8-27B nachgeschoben — unter Apache 2.0, klein genug für eine einzelne Grafikkarte und mit Benchmarkzahlen, die der Hersteller ohne zu zögern neben ein kommerzielles Spitzenmodell stellt. Huggingface hat für das Release sogar eine Countdown-Seite geschaltet. Die Erwartungshaltung war entsprechend: Der Vorgänger Qwen3.6 galt in der Selfhosting-Szene als die beste selbst betreibbare Alternative zu den Modellen von OpenAI und Anthropic, gerade für agentische Arbeit und zum Programmieren.

Ich gehe in diesem Artikel der Frage nach, was von dieser Ansage im Alltag übrig bleibt. Dazu schaue ich mir an, warum ein offenes Modell nicht automatisch ein lokal betreibbares ist, was die Benchmarktabellen sagen und was sie verschweigen, welche Hardware es tatsächlich braucht und wie schnell das Ergebnis dann ist. Danach kommt der Teil, den die meisten Vergleiche auslassen: der Preis, den lokales Reasoning in Wartezeit kostet, die Bereiche, in denen die kommerziellen Anbieter weiter vorne liegen, eine nüchterne Amortisationsrechnung, die Lage der Firmen, die Quellcode gar nicht erst außer Haus geben dürfen, und die Lizenzlage, die bei Qwen3.8 ausgerechnet zweigeteilt ist.

Wer die Grundlagen dahinter nachlesen will: Wie Speicherbedarf und Quantisierungsstufe zusammenhängen, steht in Quantisierung von LLMs erklärt, die Modellauswahl nach Speicherklasse in Welches Ollama-Modell?, und welche Werkzeuge überhaupt mit lokalen Modellen umgehen können, in KI-Coding-Assistenten. Warum Reasoning-Modelle sich anders verhalten als klassische Chat-Modelle, erklärt Reasoning-Modelle erklärt.

Die praktische Seite — wie du ein lokales Modell mit Ollama, llama.cpp oder vLLM startest und in Editor und Agent einbindest — behandelt der Folgeartikel Lokale Modelle einbinden: Ollama, llama.cpp und vLLM im Editor und im Agenten, der am 1. September 2026 erscheint.

Was im August passiert ist

Alibaba hat im August 2026 in drei Schritten geliefert: erst das Spitzenmodell in der Cloud, dann dessen Gewichte, dann das kleine Modell für den Eigenbetrieb. Am 3. August stellte Qwen, die KI-Abteilung des Cloudanbieters, Qwen3.8-Max vor — ein Mixture-of-Experts-Modell mit 2,4 Billionen Parametern, von denen pro Token 95 Milliarden aktiv sind, mit Text-, Bild- und Videoeingabe und einem Kontextfenster von einer Million Token. Zu haben war es zunächst nur über die hauseigene Cloud, verbunden mit dem Versprechen, die Gewichte „nächste Woche" nachzureichen.

Mit ein paar Tagen Verspätung kam der 12. August: Qwen/Qwen3.8-2.4T-A95B landete auf Huggingface, in BF16 und als FP8-Variante. Zwei Einschränkungen fielen dabei sofort auf. Erstens ist der offene Checkpoint reines Text-Modell — die Bild- und Videofähigkeiten sowie das Millionen-Token-Fenster, die das gehostete Produkt auszeichnen, sind nicht Teil des Downloads. Zweitens steht dieser Download nicht unter einer Standardlizenz, sondern unter einer eigenen Qwen3.8-Max-Lizenz mit Umsatzbeteiligungsklausel. Dazu später mehr.

Der eigentlich relevante Termin für Entwickler war der 15. August: Qwen3.8-27B, 27 Milliarden Parameter, dichte Architektur, nativ multimodal, 262.144 Token Kontext, Apache 2.0 — ohne Schwellenwerte, ohne Zusatzbedingungen. Das ist das Modell, über das die Selfhosting-Community seit Wochen spekuliert hatte, und es ist auch das Modell, das im Rest dieses Artikels gemeint ist, wenn von „lokal" die Rede ist. Die deutschsprachige Fachpresse hat es umgehend ausprobiert: Jan Mahn hat für heise online eine komplette REST-API für eine Bestandsverwaltung samt Benutzerverwaltung und rollenbasierter Rechteprüfung generieren lassen — der Code kompilierte im ersten Anlauf, das Modell erkannte selbstständig Codeduplikate und begann zu refaktorieren.

Bemerkenswert an dieser Reihenfolge ist das Muster dahinter. Ein Anbieter zeigt zuerst, was er kann, verkauft es über die eigene Cloud und gibt erst danach die Gewichte frei — und zwar gestaffelt: das große Modell unter Vorbehalt, das kleine ohne. Für Entwickler heißt das, dass der Abstand zwischen „bestem verfügbaren Modell" und „bestem selbst betreibbaren Modell" nicht mehr in Jahren gemessen wird, sondern in Wochen bis Monaten. Vor zwei Jahren war lokale KI ein Kompromiss, den man in Kauf nahm. 2026 ist sie eine Entscheidung, die man begründen muss — in beide Richtungen.

Was „lokal" 2026 überhaupt heißt

Ein offenes Modell ist noch lange kein lokales Modell — entscheidend ist nicht die Lizenz, sondern die Architektur. Qwen3.8-Max ist ein Mixture-of-Experts-Modell: Pro Token rechnet nur ein Bruchteil des Netzes, in diesem Fall 95 von 2.400 Milliarden Parametern. Das spart Rechenzeit, aber eben nicht Speicher. Welcher Experte gebraucht wird, entscheidet sich pro Token neu, also müssen alle Gewichte greifbar sein. Selbst in aggressiver 4-Bit-Quantisierung landet man bei diesem Modell im Bereich von gut einem Terabyte, nur für die Gewichte. Das ist Rechenzentrumsklasse, kein Arbeitsplatzrechner.

Die Faustformel dafür ist simpel: Parameterzahl mal Bytes pro Parameter. In 16 Bit sind das zwei Byte, in 8 Bit eines, in 4 Bit ein halbes. Dazu kommt der Speicher für den Kontext, der mit dessen Länge wächst und bei 262.144 Token kein Rundungsfehler mehr ist. Die Details dazu stehen in Quantisierung von LLMs erklärt; für hier reicht das Bild:

Speicher      Was damit tatsächlich läuft
──────────────────────────────────────────────────────────────
   8 GB       kleine Modelle bis ~8B, 4-Bit; für Code grenzwertig
  16 GB       ~14B in 4 Bit, oder 27B nur in stark reduzierten Quants
  24 GB       Qwen3.8-27B in 4/5 Bit  ◄── die relevante Schwelle
  32 GB       Qwen3.8-27B in 4 Bit mit langem Kontext, komfortabel
  64 GB       Qwen3.8-27B in 8 Bit, produktionsnah
──────────────────────────────────────────────────────────────
 1000 GB+     Qwen3.8-Max — offen, aber nicht für dich

Genau deshalb hat die Community auf den 27B gewartet und nicht auf den Max. Ein dichtes Modell dieser Größe ist die einzige Klasse, in der sich „Spitzenmodell" und „läuft auf meinem Schreibtisch" derzeit überschneiden. Und es ist die Klasse, in der Qwen seit Version 3.6 den Ton angibt.

Illustration zweier aneinandergrenzender Räume im Schnitt: links ein Arbeitszimmer, auf dem Schreibtisch eine kleine leuchtende Kugel; rechts füllt eine riesige Kugel derselben Art den gesamten Nebenraum vom Boden bis zur Decke und passt nicht durch die Tür dazwischen

Illustration zweier aneinandergrenzender Räume im Schnitt: links ein Arbeitszimmer, auf dem Schreibtisch eine kleine leuchtende Kugel; rechts füllt eine riesige Kugel derselben Art den gesamten Nebenraum vom Boden bis zur Decke und passt nicht durch die Tür dazwischen

Bildunterschrift: Beide Modelle sind offen — nur eines davon passt in dein Zimmer. Qwen3.8-Max ist mit 2,4 Billionen Parametern Rechenzentrumsklasse, das dichte 27B-Modell steht auf dem Schreibtisch.

Die Benchmark-Lage — und was sie nicht sagt

Qwen stellt sein 27-Milliarden-Modell in der eigenen Model Card neben Anthropics Opus 4.6 Max und gewinnt dabei vier von sieben Vergleichen. Das ist bemerkenswert und verdient trotzdem einen zweiten Blick.

Benchmark Qwen3.8-27B Opus 4.6 Max (laut Qwen)
SWE-bench Pro 61,7 53,4
Terminal-Bench 2.1 73,0 78,2
LiveCodeBench v6 90,3 88,8
GPQA Diamond 89,2 91,3
OSWorld-Verified 84,3 72,7
AndroidWorld 81,9 62,0
WebArena-Verified 64,8 —

Kurz übersetzt, was da gemessen wird: SWE-bench Pro stellt echte Fehlerberichte aus echten Repositories, die das Modell durch einen lauffähigen Patch lösen muss — die Tests entscheiden, nicht ein Gutachter. Terminal-Bench misst Aufgaben, die über die Kommandozeile erledigt werden, also Werkzeuggebrauch statt Textproduktion. LiveCodeBench sammelt frische Programmieraufgaben, die nach dem Trainingsstichtag entstanden sind, um Auswendiglernen auszuschließen. OSWorld und AndroidWorld prüfen die Bedienung von Desktop- und Mobilsystemen. Diese fünf Namen decken also ganz unterschiedliche Fähigkeiten ab, und ein Modell kann bei einem davon glänzen und beim nächsten durchfallen.

Der Sprung gegenüber der eigenen Vorgängerversion ist dabei fast noch beeindruckender als der Vergleich nach außen: Terminal-Bench 2.1 klettert von 63,4 auf 73,0, SWE-bench Pro von 53,5 auf 61,7, LiveCodeBench v6 von 83,9 auf 90,3, OSWorld-Verified von 63,9 auf 84,3. Bei DeepSWE 1.1 geht es von 13,3 auf 42,2 — in einer Generation, bei gleicher Modellgröße.

Und jetzt die Einschränkungen, die in keiner Pressemitteilung stehen. Erstens sucht sich jeder Hersteller sein Vergleichsmodell selbst aus, und Opus 4.6 Max ist im August 2026 nicht mehr die Spitze dessen, was Anthropic anbietet. Zweitens sind Benchmarknamen keine Normen: SWE-bench Pro und SWE-bench Verified sind verschiedene Aufgabensammlungen mit verschiedenen Schwierigkeitsgraden, und die meisten Seiten, die eine Zahl zitieren, sagen nicht dazu, welche gemeint ist. Drittens — und das wiegt am schwersten — hängt das Ergebnis fast so sehr am Harness wie am Modell: Wie viele Versuche darf das Modell, welche Werkzeuge bekommt es, wie lang darf es denken? Zwei Zahlen aus zwei Tabellen sind ohne diese Angaben schlicht nicht vergleichbar.

Wie stark das durchschlägt, zeigt die unabhängige Messung von Artificial Analysis eindrucksvoll. Dieselbe Modelldatei erreicht dort im Intelligence Index 52 Punkte bei Reasoning-Stufe „xhigh", 44 bei „medium" und 35 ohne Reasoning. Das sind keine Nuancen, das sind drei verschiedene Modelle im selben Download. Wer Benchmarkzahlen liest, ohne die Reasoning-Einstellung zu kennen, liest im Grunde gar nichts. Und wer das Modell zu Hause mit Standardeinstellungen startet, bekommt nicht automatisch die 52.

Hardware-Realität

Für Qwen3.8-27B brauchst du realistisch 24 GB Speicher — und musst dich zwischen Genauigkeit, Kontextlänge und Tempo entscheiden. Die Ausgangswerte: In voller 16-Bit-Präzision belegt das Modell rund 56 GB, als FP8-Variante etwa 28 GB, in 4-Bit-Quantisierung rund 17 GB. Erst der letzte Wert passt auf Consumer-Hardware.

Variante Speicherbedarf Läuft auf Anmerkung
BF16 (voll) ~56 GB Profi-GPU, großer Mac Referenzqualität, praktisch nie nötig
Q8_0 ~29 GB Gewichte 48-GB-Karte, Mac ab 64 GB produktionsnah; mit großem Kontext deutlich mehr
FP8 ~28 GB Ada/Blackwell-Karten kaum messbarer Qualitätsverlust
Q5_K_M ~22 GB RTX 3090 / 4090 (24 GB) guter Kompromiss
Q4_K_M ~17–20 GB RTX 3090 / 4090 / 5090 Einstieg, spürbarer Qualitätsverlust bei langem Kontext
NVFP4 ~16 GB nur Blackwell im heise-Test ohne erkennbaren Genauigkeitsverlust

Beim Tempo wird es dann unangenehm ehrlich. Auf einem Mac Studio M3 Ultra erzeugt Qwen3.8-27B in Q4_K_M über Ollama rund 14 Token pro Sekunde — der Vorgänger Qwen3.6-27B schaffte auf derselben Maschine 28,6. Auf einem M2 Pro sind es 6,4 bis 7,9 Token pro Sekunde. Selbst professionell gehostet misst Artificial Analysis nur 46,3 Token pro Sekunde gegenüber einem Median von 101,7 bei vergleichbaren Modellen. Das neue Modell ist also nicht nur besser als sein Vorgänger, es ist auch deutlich langsamer — und zwar bei gleicher Parameterzahl.

Wer neu kauft, steht damit vor einer simplen Abwägung. Eine gebrauchte 24-GB-Karte ist der günstigste Einstieg und reicht für 4- und 5-Bit-Betrieb; eine aktuelle 32-GB-Karte liefert das höchste Tempo, solange das Modell hineinpasst; ein Mac mit viel gemeinsamem Speicher ist langsamer, aber leise, sparsam und lässt auch 8-Bit-Varianten zu, für die eine einzelne Consumer-Karte zu klein ist. Was du nicht kaufen solltest, ist Speicher, der gerade so reicht: Sobald ein Teil des Modells in den Hauptspeicher ausgelagert wird, bricht die Geschwindigkeit um eine Größenordnung ein, und aus 14 Token pro Sekunde wird eine Zumutung.

Nicht vergessen: Der Kontextspeicher kommt oben drauf. Wer die 262.144 Token wirklich nutzen will, braucht dafür Platz, und die Standardeinstellungen mancher Laufzeitumgebung greifen dabei kräftiger zu als nötig. Welche Umgebung sich wofür eignet, steht in Ollama: lokale Sprachmodelle betreiben, die Installation in Ollama installieren. Welche der drei Laufzeitumgebungen zu welchem Zweck passt und wie das Modell danach im Editor landet, gehe ich im Folgeartikel Lokale Modelle einbinden: Ollama, llama.cpp und vLLM im Editor und im Agenten Schritt für Schritt durch.

Der Preis der Denkerei

Die gute Benchmarkzahl entsteht aus Denk-Token — und lokal bezahlst du die nicht mit Geld, sondern mit Wartezeit. Artificial Analysis hat für den Durchlauf des Intelligence Index mit Qwen3.8-27B auf Stufe „xhigh" rund 160 Millionen Ausgabe-Token gebraucht. Der Median vergleichbarer Modelle liegt bei 48 Millionen. Das Modell ist also gut dreimal so geschwätzig wie der Durchschnitt, um seine 52 Punkte zu erreichen.

In der Cloud ist das eine Rechnungsposition: Der Index-Durchlauf kostete dort 693,67 US-Dollar. Lokal ist es eine Uhr, die läuft. Rechne es selbst durch: Wenn eine anspruchsvolle Aufgabe 20.000 Denk-Token verursacht und deine Maschine 14 Token pro Sekunde liefert, wartest du knapp 24 Minuten auf die Antwort. Der heise-Test deckt sich damit — dort arbeitete das Modell in Q8_0 auf einer RTX Pro 6000 Blackwell zwölf Minuten an der Bestandsverwaltungs-API, ohne zwischendurch Rückfragen zu stellen. Das Ergebnis war gut. Zwölf Minuten sind trotzdem zwölf Minuten, und sie fallen bei jedem Versuch erneut an.

Dazu kommt eine zweite Wartezeit, die in Tabellen selten auftaucht: die Verarbeitung der Eingabe. Auf einem M2 Pro wurden bei langem Eingabetext rund 63 Token pro Sekunde gemessen, bevor das Modell überhaupt anfängt zu antworten. Wer einem lokalen Assistenten 50.000 Token Projektcode vorlegt, wartet allein dafür gut zehn Minuten — jedes Mal, wenn der Kontext nicht wiederverwendet werden kann. Genau hier liegt einer der unterschätzten Vorteile der kommerziellen Anbieter, deren Caching diesen Schritt bei wiederholten Anfragen praktisch überspringt.

Daraus folgt eine praktische Regel, die in den meisten Anleitungen fehlt: Fahr die Reasoning-Stufe im Alltag herunter. „Medium" kostet dich laut Artificial Analysis acht Indexpunkte, spart aber einen erheblichen Teil der Token — und damit den größten Teil der Wartezeit. Für Refactorings, Testgenerierung, Codeerklärungen und die üblichen Kleinaufgaben ist das der bessere Betriebspunkt. Die höchste Stufe hebst du dir für die Fälle auf, in denen du wirklich einen schwierigen Entwurf brauchst. Wer wissen will, warum das kein Qwen-spezifischer Effekt ist, findet die Mechanik in Reasoning-Modelle erklärt.

Illustration einer großen Sanduhr vor einem Monitor mit vollkommen leerem Bildschirm; der meiste Sand liegt noch in der oberen Hälfte, ein dünner Strahl rieselt nach unten

Illustration einer großen Sanduhr vor einem Monitor mit vollkommen leerem Bildschirm; der meiste Sand liegt noch in der oberen Hälfte, ein dünner Strahl rieselt nach unten

Bildunterschrift: In der Cloud kostet Reasoning Geld, lokal kostet es Zeit — im heise-Test zwölf Minuten für eine einzige REST-API, und der Sand läuft bei jedem neuen Versuch von vorn.

Wo die Cloud weiterhin vorn liegt

Der Abstand ist 2026 klein geworden, aber er liegt genau dort, wo agentisches Arbeiten stattfindet: in langen Ketten aus Werkzeugaufrufen. Vier Punkte, an denen sich das im Alltag zeigt.

Kontext in der Praxis. Auf dem Papier stehen 262.144 Token, erweiterbar bis eine Million. Lokal ist das eine Speicherfrage: Jeder zusätzliche Token Kontext kostet Platz, den du neben den Gewichten nicht mehr hast. Die kommerziellen Spitzenmodelle bieten ihre Million Token dagegen ohne Zusatzaufwand für dich — das ist kein Modellvorteil, sondern ein Infrastrukturvorteil, aber du spürst ihn genauso.

Das Harness. Werkzeuge wie Claude Code oder die Assistenten der großen Anbieter sind auf ihre eigenen Modelle abgestimmt: Werkzeugdefinitionen, Wiederholungsstrategien, Kontextverwaltung, Kompaktierung. Ein lokales Modell in dieselbe Schleife zu hängen funktioniert, liefert aber selten dieselbe Zuverlässigkeit über hundert Werkzeugaufrufe hinweg. Ein einziger falsch formatierter Aufruf kippt einen Agentenlauf.

Aktualität. Das Trainingswissen eines lokalen Modells altert auf deiner Festplatte. Kommerzielle Anbieter ergänzen fehlendes Wissen serverseitig über Websuche und Dokumentenabruf; lokal musst du das selbst bauen. Bei Bibliotheken, die sich alle paar Monate ändern, ist das der Unterschied zwischen brauchbarem und plausibel klingendem Code.

Durchsatz. Ein Modell auf einer Karte bedient eine Anfrage vernünftig — nicht fünf Entwickler gleichzeitig. Sobald ein Team davon abhängt, brauchst du eine Serving-Schicht, mehrere Karten und jemanden, der das betreibt. Genau an dieser Stelle kippt die Rechnung aus dem nächsten Abschnitt.

Der fehlende Unterbau. Websuche, Dokumentenabruf, Code-Ausführung in einer Sandbox, Kompaktierung langer Verläufe — bei den kommerziellen Anbietern sind das Schalter in der API. Lokal ist jeder dieser Punkte ein eigenes Projekt, das du bauen, betreiben und aktuell halten musst. Das ist der Teil, den Modellvergleiche systematisch unterschlagen: Verglichen wird das Modell, gearbeitet wird mit dem Gesamtsystem.

Was die reine Codequalität in einer einzelnen, gut umrissenen Aufgabe angeht, ist der Unterschied dagegen kaum noch das Argument. Der heise-Test kommt zu dem Schluss, dass sich die Programmierqualität mit Claude messen kann; auffällig war vor allem eine leichte Neigung, einfache Probleme zu überkonstruieren. Das ist ein Ton, den man von kommerziellen Modellen kennt.

Rechnet sich das?

Die Hardware amortisiert sich erst bei intensiver Nutzung — und die versteckte Position in der Rechnung ist deine Zeit. Stellen wir die drei Wege nebeneinander.

Weg Einmalig Laufend
Eigene GPU (RTX 5090, 32 GB) UVP 2.099 €, Straßenpreise oft ~3.000 € Strom; bei intensiver Nutzung ein niedriger zweistelliger Betrag im Monat
Gebrauchte RTX 3090 (24 GB) ca. 700–900 US-Dollar gebraucht dito, plus Ausfallrisiko
Mac Studio M4 Max, 64 GB ab ca. 3.275 € sehr niedriger Verbrauch
Qwen3.8-27B gehostet — 0,50 $ pro Mio. Eingabe-, 3,00 $ pro Mio. Ausgabe-Token
Claude Sonnet 5 (API) — 2 $ / 10 $ pro Mio. Token
Claude Opus 5 (API) — 5 $ / 25 $ pro Mio. Token

Eine Beispielrechnung: Wer im Monat 30 Millionen Eingabe- und 3 Millionen Ausgabe-Token durch ein Spitzenmodell schiebt — das ist intensive, tägliche Agentennutzung —, landet bei Opus 5 rechnerisch bei rund 225 US-Dollar. Gegen eine 3.000-Euro-Karte gerechnet dauert die Amortisation gut ein Jahr, und in diesem Jahr hat die Gegenseite zwei Modellgenerationen nachgelegt. Wer dagegen 3 Millionen Eingabe-Token im Monat verbraucht, zahlt keine 30 Dollar und hat mit lokaler Hardware wirtschaftlich nichts gewonnen.

Wer nicht über die API arbeitet, sondern über ein Abo, rechnet noch anders: Ein Pro-Zugang liegt bei rund 17 bis 20 US-Dollar im Monat, die Max-Stufe beginnt bei 100 US-Dollar. Gegen ein 20-Dollar-Abo amortisiert sich keine Grafikkarte, auch nicht in fünf Jahren. Das muss man aussprechen, bevor man über lokale Hardware nachdenkt.

Zwei Posten fehlen in solchen Tabellen regelmäßig. Der erste ist das Prompt-Caching, das bei den kommerziellen Anbietern die Eingabekosten in agentischen Schleifen drastisch senkt: Ein Cache-Treffer kostet bei Anthropic ein Zehntel des normalen Eingabepreises, und genau die immer gleiche Projektbasis, die deine lokale Maschine bei jeder Anfrage neu durchkaut, ist der Teil, der dort fast nichts mehr kostet. Details dazu in LLM-Kosten optimieren. Der zweite bist du: Zwölf Minuten Wartezeit pro Aufgabe sind bei einem Stundensatz jeder Größenordnung teurer als die API-Kosten derselben Aufgabe. Der wirtschaftliche Grund für lokale Modelle ist deshalb selten der Preis. Es ist die Datenhoheit — und die ist ein anderes Argument, das für sich steht.

Wenn der Quellcode das Land nicht verlassen darf

Für einen Teil der Firmen ist der lokale Betrieb keine Kostenfrage, sondern die einzige zulässige Variante — und dann sind zwölf Minuten Wartezeit plötzlich verhandelbar. Betroffen ist mehr als der offensichtliche Geheimschutzbereich:

  • Auftraggeberklauseln und NDAs. Viele Rahmenverträge untersagen, Projektinhalte an Dritte weiterzugeben oder außerhalb der EU zu verarbeiten. Ein Cloud-Assistent, der zum Beantworten einer Frage halbe Repositories mitschickt, ist genau diese Weitergabe — auch wenn das im Alltag niemand so nennt.
  • Behördenaufträge. Wer für die öffentliche Hand arbeitet, stößt schnell auf Einstufungen wie „Verschlusssache – nur für den Dienstgebrauch". Damit sind Verarbeitungsketten über externe Dienste faktisch ausgeschlossen.
  • Kritische Infrastrukturen. Betreiber nach BSI-Kritisverordnung haben zusätzliche Anforderungen an Verfügbarkeit, Integrität und Vertraulichkeit, die sich mit einer externen KI-Pipeline schwer vereinbaren lassen.
  • Berufsgeheimnisträger und ihre Dienstleister. Kanzleien, Praxen, Steuerberatungen und die IT-Firmen, die deren Systeme betreuen, arbeiten an Daten, deren Weitergabe strafbewehrt ist.
  • Abgeschottete Netze. In einem Netz ohne Internetzugang gibt es schlicht keine Cloud-Option. Ollama und llama.cpp laufen nach der Installation ohne jede Verbindung nach außen.

Die Rechtslage dazu ist nüchterner, als die Debatte oft klingt: Die Übermittlung in die USA ist nicht pauschal verboten. Der Angemessenheitsbeschluss zum EU-US Data Privacy Framework vom 10. Juli 2023 gilt, und die Klage des Abgeordneten Philippe Latombe dagegen hat das Gericht der EU am 3. September 2025 abgewiesen. Allerdings ist das Rechtsmittel dagegen beim Europäischen Gerichtshof anhängig, und nach Safe Harbor und Privacy Shield sind das die dritte Konstruktion und die dritte Klage. Wer heute eine Toolchain darauf gründet, plant mit einem Beschluss, der schon zweimal kassiert wurde. Genau diese Unsicherheit ist der Grund, warum Compliance-Abteilungen die Frage lieber technisch lösen als vertraglich.

Wichtig ist dabei die Reihenfolge: Die vertragliche Ebene ist meist strenger als das Datenschutzrecht. Ein Auftragsverarbeitungsvertrag mit einem US-Anbieter kann sauber sein und die NDA mit deinem Kunden trotzdem verletzen — und Quellcode enthält oft gar keine personenbezogenen Daten, sondern nur Geschäftsgeheimnisse, für die die DSGVO überhaupt nicht zuständig ist. Der lokale Betrieb löst beide Fragen auf einen Schlag, weil nichts das Haus verlässt.

Was er nicht löst: Urheberrechts- und Lizenzfragen am generierten Code bleiben identisch, die Mitbestimmung des Betriebsrats bei Leistungs- und Verhaltenskontrolle ebenfalls, und intern musst du weiterhin regeln, wer welchen Code sehen darf. Als Zwischenweg zwischen eigener Karte und US-Cloud bleibt ein europäischer Anbieter, der ein offenes Modell hostet: Damit gibst du die Daten zwar weiterhin aus der Hand, aber innerhalb der EU und an einen Vertragspartner, den du auswählen kannst. Die Einordnung dazu steht in KI, Datenschutz und Recht.

Die Lizenzfrage

Die beiden Qwen3.8-Modelle stehen unter grundverschiedenen Lizenzen, und ausgerechnet das kleine ist das unkomplizierte. Qwen3.8-27B kommt unter Apache 2.0 — keine Nutzerschwellen, keine Umsatzgrenzen, keine Namensnennungspflicht im Produkt, kommerzielle Nutzung eingeschlossen. Das ist so unproblematisch, wie eine Modelllizenz sein kann.

Beim offenen Qwen3.8-Max liegt der Fall anders. Er steht unter einer eigenen Qwen3.8-Max-Lizenz: Wer das Modell als Model-as-a-Service oder als KI-Arbeitsassistenten anbietet und mit verbundenen Unternehmen über 50 Millionen US-Dollar Umsatz in zwölf Monaten kommt, braucht eine gesonderte Lizenz. Oberhalb von 100 Millionen monatlich aktiven Nutzern oder 20 Millionen Dollar Monatsumsatz muss der Modellname sichtbar genannt werden. Die konkreten Beteiligungssätze waren nach Berichten Ende August noch nicht final ausverhandelt. Für die allermeisten Leser ist das irrelevant — aber wer ein Produkt auf Modellgewichten baut, prüft solche Klauseln besser vor dem Download als danach.

Kurze Prüfliste, bevor ein offenes Modell in einer Firma landet:

  • Lizenztext gelesen — Apache 2.0/MIT oder Herstellerlizenz mit Schwellen?
  • Gilt die Lizenz für die Gewichte, die Ausgaben und die abgeleiteten Modelle?
  • Namensnennung im Produkt erforderlich?
  • Gewährleistung und Haftung geklärt — offene Gewichte kommen ohne beides
  • Interner Betrieb dokumentiert: wer aktualisiert die Modelle, wer prüft neue Versionen?
  • Herkunft der Trainingsdaten bewertet, soweit überhaupt offengelegt

Das Feld daneben

Qwen3.8-27B ist derzeit das beste, was auf einen Arbeitsplatzrechner passt — die stärkeren offenen Modelle passen dort nicht hin. Ein Blick auf die Konkurrenz macht das deutlich:

Modell Architektur Kontext Lizenz Realistisch lokal?
Qwen3.8-27B 27B dicht 262k Apache 2.0 ja, ab 24 GB
Devstral 2 (Mistral) klein, dicht — Apache 2.0 ja, Arbeitsplatzklasse
GLM-5.2 744B MoE, 40B aktiv 1M MIT nein, Serverklasse
Kimi K2.6 1T MoE, ~32B aktiv 256k Modified MIT nein
DeepSeek V4 Pro 1,6T MoE, 49B aktiv 1M MIT nein
Qwen3.8-Max (offen) 2,4T MoE, 95B aktiv — eigene Lizenz nein

Die Pointe dieser Tabelle: Vier der sechs Zeilen sind offene Modelle, die du trotzdem mieten musst. „Open Weights" heißt 2026 in erster Linie, dass du den Anbieter frei wählen kannst — nicht, dass du keinen brauchst. Nur die ersten beiden Zeilen bedeuten echte Unabhängigkeit.

Für alle anderen gilt: Sie sind interessant, wenn du ohnehin über eine API arbeitest und nur den Anbieter wechseln willst — etwa zu einem europäischen Hoster, der eines dieser Modelle betreibt. Dann bekommst du niedrigere Preise als bei den Spitzenmodellen und behältst die Wahl, den Anbieter zu wechseln, ohne dass sich dein Modell ändert. Das ist ein reales Argument, nur eben ein anderes als Datenhoheit. Wer wirklich nichts aus dem Haus geben darf, landet bei Qwen3.8-27B oder bei einem der kleinen Mistral-Modelle — und bei der Frage, wie viel Speicher die Maschine unter dem Schreibtisch hat.

Häufige Fragen

Reicht eine 24-GB-Grafikkarte für Qwen3.8-27B? Ja, in 4- oder 5-Bit-Quantisierung. Q4_K_M liegt bei rund 17 bis 20 GB, Q5_K_M bei etwa 22 GB — beides passt auf eine RTX 3090, 4090 oder 5090, solange der Kontext nicht ausgereizt wird. Für langen Kontext oder 8-Bit-Qualität brauchst du 32 GB und mehr.

Ist Qwen3.8-27B wirklich so gut wie Claude? In einzelnen, klar umrissenen Programmieraufgaben kommt es erstaunlich nah heran, und in Qwens eigener Tabelle liegt es bei SWE-bench Pro sogar vor Opus 4.6 Max. Über lange Agentenläufe mit vielen Werkzeugaufrufen, bei aktuellem Bibliothekswissen und beim Tempo liegen die kommerziellen Anbieter weiter vorn.

Warum ist mein lokales Modell so langsam? Meistens wegen der Reasoning-Stufe. Qwen3.8-27B erzeugt auf höchster Stufe ein Vielfaches an Denk-Token; bei 14 Token pro Sekunde summiert sich das zu Minuten. Setz die Stufe auf „medium" oder „low" herunter und prüfe, ob das Modell wirklich vollständig im Grafikspeicher liegt.

Was ist der Unterschied zwischen Qwen3.8-Max und Qwen3.8-27B? Der Max ist ein Mixture-of-Experts-Modell mit 2,4 Billionen Parametern für den Rechenzentrumsbetrieb, der 27B ein dichtes Modell für einzelne Karten. Beide sind offen, aber nur der 27B ist praktisch selbst betreibbar — und nur er steht unter Apache 2.0.

Darf ich Qwen3.8-27B kommerziell einsetzen? Ja. Apache 2.0 erlaubt kommerzielle Nutzung, Veränderung und Weitergabe ohne Umsatzschwellen. Die Umsatzbeteiligungsklauseln betreffen ausschließlich die offenen Max-Gewichte, und auch dort nur Anbieter jenseits der 50-Millionen-Dollar-Grenze.

Darf ich Kundencode überhaupt durch einen Cloud-Assistenten schicken? Das entscheidet nicht die DSGVO allein, sondern zuerst dein Vertrag. Viele Rahmenverträge und NDAs untersagen die Weitergabe an Dritte oder die Verarbeitung außerhalb der EU — unabhängig davon, ob personenbezogene Daten im Code stehen. Prüf die Klausel, bevor du das Werkzeug einrichtest, nicht danach.

Lohnt sich lokale KI für ein kleines Team? Für gemeinsames, gleichzeitiges Arbeiten selten — eine Karte bedient eine Anfrage vernünftig. Sinnvoll wird es, wenn Datenschutz den Ausschlag gibt oder wenn jeder seine eigene Maschine hat. Sonst ist eine API mit Auftragsverarbeitungsvertrag meist die günstigere und schnellere Lösung.

Brauche ich für Code das größte verfügbare Modell? Nein. Für Autovervollständigung und kleine Umbauten reichen deutlich kleinere Modelle bei einem Vielfachen des Tempos. Das große Modell lohnt sich für Entwurf, Refactoring über mehrere Dateien und Fehlersuche — die Auswahl nach Zweck ist wichtiger als die nach Parameterzahl.

Zusammenfassung und praktische Tipps

  • Nur der 27B zählt für dich. Qwen3.8-Max ist offen, aber mit 2,4 Billionen Parametern Rechenzentrumsklasse. Das dichte 27B-Modell ist das, was auf eine einzelne Karte passt.
  • 24 GB sind die Schwelle. 4-Bit liegt bei rund 17 GB, 5-Bit bei 22 GB. Wer 32 GB oder einen Mac mit viel Speicher hat, gewinnt vor allem Kontextlänge.
  • Benchmarkzahlen ohne Reasoning-Stufe sind wertlos. Dieselbe Datei erreicht 52, 44 oder 35 Indexpunkte, je nach Einstellung.
  • Der Hersteller sucht sich den Gegner aus. Qwens Tabelle vergleicht mit Opus 4.6 Max, nicht mit dem aktuellen Spitzenmodell. Rechne das ein.
  • Tempo ist die eigentliche Währung. 14 Token pro Sekunde auf einem M3 Ultra, 46 in professionellem Hosting — gegenüber einem Median von rund 100 bei vergleichbaren Modellen.
  • Reasoning-Stufe herunterdrehen. „Medium" kostet acht Indexpunkte und spart den Großteil der Wartezeit. Das ist der beste Alltagskompromiss.
  • Der Generationssprung ist echt. SWE-bench Pro von 53,5 auf 61,7, Terminal-Bench von 63,4 auf 73,0, OSWorld von 63,9 auf 84,3 — bei gleicher Modellgröße.
  • Wirtschaftlich rechnet sich lokal selten. Erst bei sehr intensiver Nutzung amortisiert sich die Hardware, und deine Wartezeit steht in keiner Tabelle.
  • Lizenz vor Download prüfen. Apache 2.0 beim 27B ist unkritisch; die Max-Gewichte tragen eine eigene Lizenz mit Umsatzschwellen.
  • Datenhoheit ist das tragfähige Argument. Kein Drittlandtransfer, keine Auftragsverarbeitung, kein Prompt verlässt das Haus.
  • Der Vertrag ist strenger als das Gesetz. NDAs, Behördenauflagen und KRITIS-Anforderungen schließen Cloud-Assistenten oft aus, auch wenn die DSGVO sie erlauben würde.

Mein Rat: Betreib das Modell lokal für alles, was den Betrieb nicht verlassen darf — Kundencode, personenbezogene Daten, alles unter Geheimhaltung. Dafür ist Qwen3.8-27B die derzeit beste Wahl, und zwar mit deutlichem Abstand zu allem anderen, was auf eine Karte passt. Für die tägliche Arbeit an offenem Code würde ich es nicht zum Standardwerkzeug machen: Der Unterschied in der Codequalität ist inzwischen klein, der Unterschied im Tempo ist es nicht, und zwölf Minuten Wartezeit pro Aufgabe sind ein Preis, den man nach der dritten Aufgabe nicht mehr zahlen will. Die ehrlichste Aufteilung sieht so aus: lokale Modelle für Vertrauliches und für Aufgaben, die im Hintergrund laufen dürfen, kommerzielle Modelle für interaktive Arbeit. Wer das trennt, holt aus beidem das Beste heraus — und muss sich nicht zwischen Datenschutz und Produktivität entscheiden.

Ressourcen