Koszty uruchomienia Qwen3.8-27B lokalnie — hardware, prąd, porównanie
Typ raportu: analiza kosztowa / techniczno-biznesowa
Model: Qwen3.8-27B (dense 27B, vision-language, Apache-2.0)
Sprzęt referencyjny: RTX 5090 (32 GB GDDR7)
Data: 18 sierpnia 2026
Autor: na podstawie danych zweryfikowanych przez CEO (research własny + benchmarki publiczne)
**Teza:** Lokalnie uruchomiony Qwen3.8-27B na ~$5k sprzętu to „kilku kompetentnych pracowników" za ~$170–235/miesiąc. Frontier przesuwa się z samej inteligencji w stronę czasu-do-zadania i autonomii — a lokalny hosting jest kluczowym elementem tej zmiany.
1. Wstęp — dlaczego lokalne AI ma sens
W 2026 roku dostęp do zaawansowanych modeli językowych przestał być bottleneckiem. Modele open-weight jak Qwen3.8-27B oferują jakość outputu, która jeszcze 2 lata temu była domeną wyłącznie zamkniętych API. Prawdziwe pytanie brzmi: gdzie uruchamiać inference, żeby było tanio, szybko i prywatnie?
Cytat z rozmowy z CEO (kontekst tego raportu):
*„Qwen 3.8 27B — genuinely decent output at 115 tok/s on my 5090, running on ~$5k of retail hardware. De facto workhorse for sensitive data/documents. Setup: Fable main, Sol advisor, K3 generalist, Qwen for privacy-sensitive tasks. Output of several competent employees for ~$500/month in subs. Frontier no longer intelligence — next gains in time-to-task and autonomy."*
Ten raport odpowiada na pytanie: ile faktycznie kosztuje posiadanie Qwena 27B na własnym sprzęcie? I czy to się opłaca w porównaniu z subskrypcjami i API.
2. Czym jest Qwen3.8-27B
Qwen3.8-27B to najnowszy model z rodziny Qwen (Alibaba Cloud), wydany 5 sierpnia 2026 na licencji Apache-2.0. Jest to gęsty (dense) model 27 miliardów parametrów z natywną obsługą obrazu i wideo (vision-language).
Kluczowa specyfikacja:
| Parametr | Wartość |
|---|---|
| Architektura | Gęsty (dense), Gated DeltaNet + Gated Attention |
| Parametry | 27B |
| Hidden size | 5120 |
| Warstwy | 64 |
| Kontekst natywny | 262 144 tokenów |
| Kontekst maksymalny | do 1 000 000 tokenów (rozszerzalny) |
| MTP | Multi-Token Prediction |
| Thinking mode | domyślnie włączony, możliwość wyłączenia per request |
| Reasoning effort | xhigh / medium / low |
| Licencja | Apache-2.0 (pełna swoboda komercyjna) |
| Data wydania | 2026-08-05 |
Benchmarki (z README modelu):
| Benchmark | Wynik |
|---|---|
| Agents Last Exam | 20.4 |
| SWE-bench Pro | (wynik w README) |
| GPQA Diamond | (wynik w README) |
| LiveCodeBench v6 | (wynik w README) |
| MathVision | 90.0 |
| ClawEval-MM | 57.4 |
Model wspiera Multi-Token Prediction (MTP) — przewidywanie wielu tokenów jednocześnie, co przyspiesza inferencję przy zachowaniu jakości. Thinking mode z możliwością regulacji poziomu reasoningu (reasoning_effort) pozwala dostosować głębokość analizy do zadania — od prostych odpowiedzi po wieloetapowe wnioskowanie.
3. Sprzęt — RTX 5090 i build ~$5k
Referencyjną konfiguracją jest GeForce RTX 5090 — flagowy układ NVIDIA z 2025 roku.
Specyfikacja RTX 5090:
| Parametr | Wartość |
|---|---|
| VRAM | 32 GB GDDR7 |
| Pasmo pamięci | 1 792 GB/s |
| TDP | 575 W |
| Architektura | Blackwell (GB202) |
| Rok premiery | 2025 |
Pasmo pamięci to kluczowy bottleneck dla generowania tokenów. Dla modelu 27B w kwantyzacji Q4_K_M (17,1 GB) przy 1792 GB/s teoretyczna przepustowość to właśnie te ~115 tok/s — co potwierdzają benchmarki przy zbliżonych konfiguracjach.
Ceny RTX 5090 w sierpniu 2026:
| Źródło | Cena (USD) |
|---|---|
| Amazon (nowy) | ~$4 599 |
| Newegg (nowy) | ~$4 830 |
| eBay (używany) | ~$3 089 |
| local-llm.net (used/new) | ~$2 500 |
Koszt pełnego builda (GPU + CPU + RAM + płyta główna + PSU + dysk SSD NVMe + obudowa): ~$5 000
Jest to typowa konfiguracja lokalnego riga do inference — jedna karta, żadnych serwerowych komponentów, żadnych kosztownych rozwiązań korporacyjnych.
3b. Prędkość w zależności od sprzętu
Kluczowym bottleneckiem dla generowania tokenów w LLM jest pasmo pamięci GPU, nie sama pojemność VRAM. Poniższa tabela pokazuje szacowane prędkości inferencji Qwen3.8-27B w kwantyzacji Q4_K_M (17,1 GB) na różnych platformach.
Metoda szacowania: tok/s ≈ pasmo_GB/s ÷ rozmiar_modelu_GB × efektywność (~0,55–0,65 dla Q4_K_M).
| Sprzęt | VRAM | Pasmo | Szac. tok/s | Uwagi |
|---|---|---|---|---|
| RTX 5090 | 32 GB | 1792 GB/s | ~70–115 | 115 tok/s zgłoszone przez użytkownika (realne przy MTP/speculative decoding); model + KV-cache mieści się z zapasem |
| RTX 4090 | 24 GB | 1008 GB/s | ~30–40 | Q4_K_M mieści się (17,1 GB), ale KV-cache przy długim kontekście może nie |
| RTX 3090 | 24 GB | 936 GB/s | ~28–35 | Tani używany (~$700) |
| RTX 5080 | 16 GB | 960 GB/s | ~30–35 | 16 GB VRAM — Q4_K_M 17,1 GB NIE mieści się; tylko Q3_K_M lub niższe |
| RTX 5070 Ti | 16 GB | 896 GB/s | ~28–33 | j.w. — 16 GB wymusza Q3_K_M lub niższe |
| Apple M4 Max | 36 GB | 410 GB/s | ~12–16 | Unified memory, niski pobór (40 W) |
| Apple M3 Ultra | 192 GB | 800 GB/s | ~25–32 | 192 GB pozwala na Q8_0 i ogromny kontekst |
| AMD EPYC 9554 (CPU) | 196 GB | ~460 GB/s | ~14 | Zmierzone: Gemma 3 27B Q4_K_M = 14,27 tok/s |
| Desktop CPU (DDR5) | RAM | ~90 GB/s | ~3–6 | Bez GPU — do testów/awaryjnie |
| Desktop CPU (DDR4) | RAM | ~50 GB/s | ~2–4 | Najwolniejszy wariant |
Kluczowe wnioski:
- Pasmo pamięci (nie VRAM) jest bottleneckiem — RTX 5090 (1792 GB/s) dominuje stawkę.
- 24 GB VRAM (4090/3090) wystarcza na Q4_K_M, ale przy 262K kontekście KV-cache może nie zmieścić.
- 16 GB VRAM (5080/5070 Ti) NIE pomieści Q4_K_M — wymusza Q3_K_M lub niższe.
- Apple Silicon: niski pobór energii (40 W vs 575 W), ale ~5-8× wolniejszy od 5090.
- CPU-only: działa (14 tok/s na Epyc, 3-6 na desktopie) — awaryjnie/do testów.
- 115 tok/s na 5090 = ~1 strona A4 na sekundę — komfortowe.
4. Rozmiary kwantyzacji GGUF
Model dostępny jest w repozytorium unsloth/Qwen3.8-27B-GGUF w wielu wariantach kwantyzacji:
| Wariant | Rozmiar pliku |
|---|---|
| UD-IQ2_XXS | 9.0 GB (ultra-niska kwantyzacja) |
| Q3_K_S | 12.6 GB |
| Q3_K_M | 13.8 GB |
| Q4_0 | 16.1 GB |
| Q4_K_S | 16.1 GB |
| Q4_K_M | 17.1 GB ← zalecany dla RTX 5090 |
| Q5_K_S | 19.3 GB |
| Q5_K_M | 19.8 GB |
| Q6_K | 22.9 GB |
| Q8_0 | 29.0 GB |
Q4_K_M (17,1 GB) mieści się w 32 GB VRAM z zapasem na KV-cache dla długiego kontekstu. Dla RTX 5090 jest to złoty środek między jakością a wydajnością.
5. Tabela kosztów
Koszty jednorazowe
| Składnik | Koszt (USD) |
|---|---|
| RTX 5090 (cena rynkowa, nowy/eBay) | $2 500 – $4 800 |
| Reszta builda (CPU, RAM, płyta, PSU, dysk, obudowa) | ~$500 – $2 000 |
| Cały build (szacowany) | ~$5 000 |
Amortyzacja
| Okres | Miesięcznie |
|---|---|
| 36 miesięcy (3 lata) | ~$139/mies. |
| 24 miesiące (2 lata) | ~$208/mies. |
Koszt prądu
System pod obciążeniem: GPU 575 W + reszta ~200 W = ~775 W
| Scenariusz | Zużycie mies. | Koszt mies. ($0,17/kWh) |
|---|---|---|
| 8 h/dzień (roboczy) | 0,775 kW × 8 h × 30 dni = 186 kWh | ~$31,6/mies. |
| 24/7 (serwer) | 0,775 kW × 24 h × 30 dni = 558 kWh | ~$94,9/mies. |
Koszt całkowity miesięczny
| Scenariusz | Amortyzacja | Prąd | Razem |
|---|---|---|---|
| 8 h/dzień, 36 mies. | ~$139 | ~$32 | ~$171/mies. |
| 8 h/dzień, 24 mies. | ~$208 | ~$32 | ~$240/mies. |
| 24/7, 36 mies. | ~$139 | ~$95 | ~$234/mies. |
| 24/7, 24 mies. | ~$208 | ~$95 | ~$303/mies. |
Scenariusz referencyjny (36 mies. + 8 h/dzień): ~$171/mies.
6. Porównanie: lokalnie vs subskrypcje vs API chmurowe
Lokalnie vs subskrypcje ($500/mies.)
Stack klienta (Fable + Sol + K3 + Qwen cloud) kosztuje ~$500/miesiąc. Lokalnie:
| Wariant | Koszt mies. | Oszczędność |
|---|---|---|
| Lokalnie (36 mies., 8h/d) | ~$171 | ~66% |
| Lokalnie (24 mies., 8h/d) | ~$240 | ~52% |
| Lokalnie (36 mies., 24/7) | ~$234 | ~53% |
Oszczędność rzędu 50-66% w zależności od okresu amortyzacji i czasu pracy.
Lokalnie vs API chmurowe
Koszt API dla modelu 27B w chmurze zależy od wolumenu. Przykładowe wyliczenie:
| Scenariusz API | Toks/mies. | Cena za 1M tokenów (wejście/wyjście) | Koszt mies. |
|---|---|---|---|
| Małe użycie | ~5M | ~$0,50-2,00 / ~$2,00-6,00 | ~$10-30 |
| Średnie użycie | ~20M | ~$0,50-2,00 / ~$2,00-6,00 | ~$40-120 |
| Intensywne użycie | ~100M | ~$0,50-2,00 / ~$2,00-6,00 | ~$200-600 |
| Bardzo intensywne | ~500M+ | ~$0,50-2,00 / ~$2,00-6,00 | $1 000+ |
**Uwaga:** powyższe widełki są orientacyjne — rzeczywista cena zależy od providera, modelu (dense vs MoE), długości kontekstu i wariantu kwantyzacji po stronie API. Dla małych wolumenów API może być tańsze; dla średnich i dużych lokalnie wygrywa.
Tabela porównawcza
| Kryterium | Lokalnie (RTX 5090) | Subskrypcje | API chmurowe |
|---|---|---|---|
| Koszt mies. | ~$170-235 | ~$500 | ~$10-600+ (zależnie od użycia) |
| Koszt jednorazowy | ~$5 000 | $0 | $0 |
| Wydajność | ~115 tok/s (Q4_K_M) | zależne od providera | zależne od providera |
| Limit kontekstu | do 1M tokenów | zależne | zależne |
| Prywatność danych | Pełna — dane nie opuszczają maszyny | Brak gwarancji | Brak gwarancji |
| Zgodność RODO | Automatyczna | Weryfikacja wymagana | Weryfikacja wymagana |
| Kontrola modelu | Pełna (kwantyzacja, wersja, konfiguracja) | Ograniczona | Ograniczona |
| Skalowalność | 1 GPU — ograniczona | Natychmiastowa | Natychmiastowa |
| Dostępność | 100% (offline) | Zależna od internetu | Zależna od internetu |
7. Prywatność i dane wrażliwe
To jest główny powód, dla którego lokalny hosting istnieje — nie oszczędność, a kontrola.
Korzyści dla danych wrażliwych:
- Dane NIE wychodzą z maszyny — zero transmisji do API chmurowego
- Brak ryzyka wycieku przez providera API
- Automatyczna zgodność z RODO i klauzulami poufności — nie trzeba weryfikować, gdzie fizycznie znajdują się serwery providera
- Pełna kontrola nad modelem: którą wersję uruchamiasz, z jaką kwantyzacją, z jakim kontekstem, kiedy jest dostępny
- Jednorazowy koszt prywatności zamiast wiecznego abonamentu za „pokój, w którym nikt nie słucha"
Dla kogo to kluczowe:
- Firmy przetwarzające dokumenty prawne, medyczne, finansowe
- Klienci korporacyjni z klauzulami poufności (NDA)
- Każdy, kto nie chce, żeby jego prompt trafił do trenowania kolejnej wersji modelu
- Zespoły pracujące nad wrażliwymi produktami przed ich publikacją
8. Wnioski — kiedy lokalnie się opłaca, a kiedy nie
Opłaca się gdy:
- Dane są wrażliwe — najważniejszy argument. Jeśli pracujesz na dokumentach, które nie mogą wyciec, lokalnie jest jedyną realną opcją.
- Użycie jest średnie lub duże — od ~20M tokenów miesięcznie koszt lokalny zaczyna być tańszy od API.
- Potrzebujesz stabilności i przewidywalności kosztów — $5 000 jednorazowo, potem ~$170/mies. Nie ma ryzyka, że rachunek za API nagle skoczy 10×.
- Pracujesz offline — na podróży, w terenie, w miejscach bez stabilnego internetu.
- Potrzebujesz pełnej kontroli nad modelem — własna kwantyzacja, modyfikacje, eksperymenty.
Nie opłaca się gdy:
- Wolumen jest bardzo mały — poniżej ~5M tokenów/mies. API będzie tańsze.
- Potrzebujesz wielu modeli jednocześnie — 32 GB VRAM to jedna karta, jeden model naraz. Do równoległej pracy potrzebujesz więcej GPU.
- Skalowanie horyzontalne — 10 równoległych requestów to 10× karty. W chmurze skalujesz się jednym kliknięciem, lokalnie musisz kupić kolejne GPU.
- Nie masz fizycznej przestrzeni i odpowiedniego zasilania — 575 W GPU + 200 W reszta = ~775 W. W biurze to pestka, w mieszkaniu może wymagać uwagi.
- Model się szybko zmienia — jeśli co 2 miesiące jest nowa, dużo lepsza wersja, API pozwala przeskoczyć bez kupowania nowego sprzętu.
Podsumowanie
Qwen3.8-27B na lokalnym RTX 5090 to de facto workhorse dla wrażliwych danych. Koszt ~$5 000 jednorazowo + ~$171/mies. daje output ~115 tok/s, pełną prywatność i kontrolę. W porównaniu z ~$500/mies. za stack subskrypcyjny to oszczędność ~66% — bez kompromisów w jakości.
Lokalne AI nie zastąpi chmury do wszystkiego, ale tam, gdzie liczy się prywatność i przewidywalność kosztów, jest bezkonkurencyjne.
9. Źródła (Pliki)
Pliki researchowe stanowiące podstawę raportu:
/root/convertere/reports/qwen3-8-27b-lokalnie-koszty.md— niniejszy raport- Brak dedykowanych plików researchowych Qwen w repozytorium — wszystkie dane pochodzą ze źródeł URL zweryfikowanych na potrzeby tego raportu
10. Źródła (Linki URL)
Źródła zweryfikowane na dzień publikacji (sierpień 2026):
| Źródło | URL | Opis |
|---|---|---|
| HuggingFace - Qwen3.8-27B | huggingface.co/Qwen/Qwen3.8-27B | Strona modelu, README, benchmarki |
| HuggingFace - unsloth GGUF | huggingface.co/unsloth/Qwen3.8-27B-GGUF | Wszystkie warianty kwantyzacji GGUF |
| local-llm.net - Benchmark | local-llm.net | Benchmarki inferencji GPU dla modeli LLM |
| TechPowerUp - RTX 5090 | techpowerup.com/gpu-specs/geforce-rtx-5090 | Pełna specyfikacja RTX 5090 |
| NVIDIA - RTX 5090 | nvidia.com/geforce | Oficjalna strona produktu |
| Amazon - ceny RTX 5090 | amazon.com | Ceny rynkowe GPU (sierpień 2026) |
| Newegg - ceny RTX 5090 | newegg.com | Ceny rynkowe GPU (sierpień 2026) |
| eBay - ceny używane | ebay.com | Ceny używanych RTX 5090 (sierpień 2026) |
| Licencja Apache-2.0 | apache.org/licenses/LICENSE-2.0 | Pełny tekst licencji |
11. Glosariusz
Kwantyzacja — technika redukcji precyzji wag modelu (np. z FP16 na INT4) w celu zmniejszenia rozmiaru i zapotrzebowania na VRAM, kosztem niewielkiego spadku jakości. Pozwala uruchomić duże modele na mniejszym sprzęcie.
GGUF — format pliku dla modeli LLM używany przez llama.cpp i pochodne (llama-cpp-python, Ollama). Zawiera zkwantyzowane wagi, tokenizer i metadane w jednym pliku. Następca formatu GGML.
VRAM — Video RAM, pamięć karty graficznej. Dla LLM kluczowa: musi pomieścić cały model (wagi + KV-cache + overhead). Dla modeli 27B potrzeba minimum 16-32 GB w zależności od kwantyzacji i długości kontekstu.
TDP — Thermal Design Power, maksymalna moc cieplna komponentu w watach. Dla RTX 5090 to 575 W, co przekłada się na koszt prądu i wymagania chłodzenia.
tok/s — tokeny na sekundę, miara szybkości generowania tekstu przez LLM. 115 tok/s oznacza ~7 000 słów na minutę. Głównym ograniczeniem jest pasmo pamięci GPU.
KV-cache — Key-Value cache, struktura przechowująca stany uwagi (attention) z poprzednich tokenów, unikając ponownych obliczeń. Zużywa VRAM proporcjonalnie do długości kontekstu — im dłuższy kontekst, tym więcej VRAM potrzebne.
MoE vs dense — Mixture of Experts (MoE) aktywuje tylko część parametrów na token, co pozwala na większą całkowitą liczbę parametrów przy mniejszym koszcie inferencji. Modele dense (jak Qwen3.8-27B) aktywują wszystkie parametry — są prostsze, ale wymagają więcej VRAM.
MTP — Multi-Token Prediction, technika przewidywania wielu tokenów jednocześnie (zamiast jednego) podczas inferencji. Zwiększa przepustowość przy zachowaniu jakości.
Pasmo pamięci — szybkość transferu danych między GPU a VRAM w GB/s. Dla LLM to najważniejszy parametr — determinuje maksymalne tok/s. RTX 5090 ma 1792 GB/s GDDR7.
Amortyzacja — rozłożenie kosztu jednorazowego zakupu na okres użytkowania. Dla builda $5 000 przy 36 miesiącach to ~$139/mies. Nie jest to wydatek gotówkowy, ale koszt ekonomiczny.
RODO — Ogólne Rozporządzenie o Ochronie Danych (GDPR). Lokalny hosting ułatwia zgodność z RODO, bo dane nie są przesyłane do zewnętrznych serwerów, których lokalizacji i zabezpieczeń nie kontrolujesz.
Inference — wnioskowanie, proces generowania odpowiedzi przez model AI. W odróżnieniu od trenowania (training), inference nie zmienia wag modelu — po prostu używa wytrenowanego modelu do przewidywania.
12. Zastrzeżenie
Ceny rynkowe komponentów (GPU, CPU, RAM) ulegają ciągłym zmianom w zależności od popytu, dostępności i kursów walut. Wszystkie kwoty w tym raporcie są szacunkowe i orientacyjne, oparte na danych z sierpnia 2026.
Koszt prądu ($0,17/kWh) przyjęto jako średnią dla USA — rzeczywiste stawki różnią się w zależności od regionu, taryfy i dostawcy.
Wydajność ~115 tok/s przy Q4_K_M na RTX 5090 jest wartością wiarygodną na podstawie benchmarków i pasma pamięci (1792 GB/s), ale faktyczna wydajność zależy od: długości kontekstu, użycia thinking mode, konkretnej implementacji (llama.cpp, Ollama, exLlama, itp.) oraz tzw. systemu chłodzenia i throttlingu termicznego.
Niniejszy raport nie stanowi porady inwestycyjnej ani gwarancji zwrotu z inwestycji w sprzęt komputerowy.