Cum să rulezi local Qwen3.8-Flash-Next ca agent de programare cu OpenCode

Arhitectura Qwen3.8-Flash-Next

Este un model MoE principal cu 125B de parametri, dar doar aproximativ 6B de parametri sunt activați per token. Include, de asemenea, încă 51B de parametri în embeddings n-gram.

Arhitectura introduce câteva idei pe care Qwen le explorează pentru Qwen4:

• Gated DeltaNet + Qwen Sparse Attention (QSA) pentru procesarea mai eficientă a contextelor lungi
• Conexiuni reziduale cu poartă (Gated Residual) pentru a îmbunătăți fluxul de informații între straturi
• Embeddings n-gram care adaugă capacitate modelului fără a necesita calcularea activă a tuturor acelor parametri

Sursa: Qwen 

Modelul are o fereastră de context nativă de 262.144 de tokeni și, teoretic, poate fi extinsă la 1 milion de tokeni folosind YaRN.

Cum se descurcă Qwen3.8-Flash-Next la programare?

Este, de asemenea, surprinzător de puternic la programare. Acestea sunt câteva dintre rezultatele raportate de Qwen, comparativ cu Qwen3.8-27B:

Acestea sunt evaluările proprii ale Qwen, deci le-aș trata în continuare ca rezultate raportate de furnizor, dar se aliniază destul de bine cu experiența mea de utilizare a modelului pentru programare.

Pregătirea serverului GPU pentru Qwen3.8-Flash-Next

Am folosit un RTX PRO 6000 cu 96GB VRAM, dar nu ai neapărat nevoie de atât de mult VRAM.

Acesta este de fapt unul dintre aspectele interesante ale Qwen3.8-Flash-Next. Pentru că llama.cpp poate descărca părți ale modelului în RAM-ul sistemului, poți folosi o placă video cu mai puțin VRAM, atâta timp cât ai suficientă memorie RAM disponibilă.

Cuantizarea Unsloth UD-Q4_K_XL pe care o folosim are aproximativ 111GB și este împărțită în patru fișiere GGUF.

Pentru setup-ul meu, aș recomanda să ai cel puțin 140GB de RAM și VRAM utilizabile combinate pentru a te asigura că există suficient spațiu pentru model, context, KV cache și overhead-ul la rulare.

Dacă ai ceva precum un H200, ai putea păstra practic totul pe GPU. Eu am ales o variantă de mijloc. 

Începe prin a-ți verifica GPU-ul:

nvidia-smi

Ar trebui să vezi placa ta video, versiunea driverului, versiunea CUDA și VRAM-ul disponibil.

Apoi, instalează pachetele necesare:

sudo apt update

sudo apt install -y \
  git \
  cmake \
  build-essential \
  curl \
  libcurl4-openssl-dev \
  python3-pip

Construirea llama.cpp cu suport pentru Qwen3.8-Flash-Next

Qwen3.8-Flash-Next folosește noua arhitectură qwen4_exp, care este foarte diferită de simpla încărcare a unui alt model Qwen3.8.

Suportul este încă foarte nou, așa că am folosit ramura Qwen3.8-Flash-Next întreținută de Unsloth, în loc să mă bazez pe un build llama.cpp mai vechi care s-ar putea să nu recunoască arhitectura. Munca corespunzătoare din llama.cpp adaugă noua arhitectură qwen4exp, QSA, embeddings n-gram și alte componente specifice modelului.

Intră în workspace:

cd /workspace

Clonează ramura Unsloth:

git clone \
  --branch qwen4exp/qwen3.8-flash-next \
  https://github.com/unslothai/llama.cpp.git

Intră în director:

cd llama.cpp

Compilează llama.cpp cu CUDA:

cmake -B build \
  -DGGML_CUDA=ON \
  -DCMAKE_BUILD_TYPE=Release

cmake --build build \
  --config Release \
  -j"$(nproc)"

La final, confirmă că llama-server a fost construit corect:

./build/bin/llama-server --version

Build-ul meu a returnat:

version: 0.3.0-dev (build 10656, commit 035e22731)
built with GNU 13.3.0 for Linux x86_64

Descărcarea modelului Qwen3.8-Flash-Next GGUF

Descărcarea modelului a fost de fapt una dintre părțile mai enervante ale acestui setup.

Am încercat mai întâi ModelScope, dar viteza nu a fost grozavă. Pe Hugging Face, descărcarea a atins inițial viteze decente, apoi a scăzut brusc la KB/s.

Hugging Face folosește acum backend-ul Xet pentru descărcări de modele mari și, de obicei, activează automat concurența adaptivă. De asemenea, oferă HF_HUB_DISABLE_XET pentru a dezactiva Xet atunci când cauzează probleme.

În cazul meu, dezactivarea Xet și descărcarea în paralel a celor patru shard-uri GGUF a funcționat mult mai bine.

Instalează CLI-ul Hugging Face:

pip install -U huggingface_hub

Dezactivează Xet pentru această descărcare:

export HF_HUB_DISABLE_XET=1
unset HF_XET_HIGH_PERFORMANCE
unset HF_XET_NUM_CONCURRENT_RANGE_GETS
unset HF_HUB_ENABLE_HF_TRANSFER

HF_HUB_ENABLE_HF_TRANSFER este oricum depreciat acum, deoarece Hugging Face a mutat transferurile mari pe Xet.

Creează directorul modelului:

cd /workspace
mkdir -p Qwen3.8-Flash-Next-GGUF

Acum descarcă toate cele patru shard-uri în paralel:

for i in 1 2 3 4; do
  shard=$(printf "%05d" "$i")

  hf download unsloth/Qwen3.8-Flash-Next-GGUF \
    "UD-Q4_K_XL/Qwen3.8-Flash-Next-UD-Q4_K_XL-${shard}-of-00004.gguf" \
    --local-dir Qwen3.8-Flash-Next-GGUF &
done

wait

Cuantizarea UD-Q4_K_XL completă are aproximativ 111GB.

Rularea Qwen3.8-Flash-Next cu llama.cpp

Întoarce-te în directorul llama.cpp:

cd /workspace/llama.cpp

Pornește serverul:

./build/bin/llama-server \
  -m /workspace/Qwen3.8-Flash-Next-GGUF/UD-Q4_K_XL/Qwen3.8-Flash-Next-UD-Q4_K_XL-00001-of-00004.gguf \
  --alias qwen3.8-flash-next \
  --host 0.0.0.0 \
  --port 8080 \
  --ctx-size 131072 \
  --parallel 1 \
  --flash-attn on \
  --fit on \
  --fit-target 4096 \
  --jinja \
  --batch-size 1024 \
  --ubatch-size 512 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 20 \
  --min-p 0.0

Am folosit deliberat o fereastră de context de 131.072 tokeni, în loc de cei 262K nativi.

Pentru agenți de programare, 131K este deja uriaș și oferă OpenCode suficient spațiu pentru fișiere sursă, rezultate ale uneltelor, jurnale de terminal și conversații lungi, fără a irosi și mai multă memorie pe context pe care probabil nu îl voi folosi.

Setările importante aici sunt:

1. --fit on permite llama.cpp să determine automat cât din model să păstreze pe GPU.

2. --fit-target 4096 îi spune să lase aproximativ 4GB memorie GPU liberi, ceea ce oferă procesului de rulare un pic de spațiu, în loc să meargă direct la limită. llama.cpp suportă oficial atât fitting automat, cât și o marjă de memorie țintă configurabilă.

3. Setările de sampling nu sunt nici ele întâmplătoare. Qwen recomandă temperature=1.0, top_p=0.95, top_k=20 și min_p=0.0 când folosești modelul în modul de gândire.

Chiar și după încărcarea completă a modelului, încă aveam suficientă memorie liberă, cu aproximativ 13GB VRAM disponibili pentru fereastra de context, KV cache și alte aplicații.

Testarea serverului Qwen3.8-Flash-Next folosind CURL

llama-server expune un API compatibil cu OpenAI.

Verifică modelul disponibil:

curl http://127.0.0.1:8080/v1/models

Ar trebui să vezi qwen3.8-flash-next.

Acum, să testăm generarea unui răspuns:

curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-flash-next",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that checks whether a number is prime."
      }
    ]
  }'

Dacă obții un răspuns valid, serverul local este gata.

Pe setup-ul meu, inițial am văzut în jur de 80 tokeni pe secundă, ceea ce m-a surprins, având în vedere că o parte a modelului se afla în RAM-ul sistemului.

Pe măsură ce contextul a devenit mai mare, am început să văd viteze mai aproape de 64 tokeni pe secundă.

Totuși, asta este extrem de utilizabil pentru un model de această dimensiune, iar arhitectura explică de ce. Chiar dacă modelul are 125B parametri principali, doar aproximativ 6B sunt activi per token.

Testarea Qwen3.8-Flash-Next cu WebUI-ul llama.cpp

Un lucru care îmi place mult la llama.cpp este că llama-server îți oferă deja un WebUI simplu.

Deschide http://localhost:8080. Dacă totul rulează corect, modelul ar trebui să fie deja disponibil.

Pentru primul meu test serios, i-am cerut să construiască dintr-o singură bucată un site web complet pentru un departament guvernamental de IT:

Create a modern, professional government IT department portfolio website in a single index.html file.
Use HTML, CSS, and JavaScript featuring a clean official design and responsive layout with smooth animations, interactive elements, and accessible government-style navigation.
It should display department overview, key services, digital transformation projects, achievements, technology initiatives, statistics, leadership/team section, latest updates, contact information, 

A fost o generare destul de mare. Modelul a „gândit” multe tokenuri, apoi a generat un întreg site într-un singur fișier HTML. A durat aproximativ 13 minute să termine, iar viteza de generare a scăzut treptat pe măsură ce contextul a crescut.

Dar rezultatul a fost mult mai bun decât mă așteptam.

A inclus grafice, animații, taburi, secțiuni diferite, stilizare responsive, interacțiuni JavaScript și un layout general surprinzător de finisat.

Partea interesantă a fost că practic a fost o generare one-shot. Nu i-am cerut explicit să adauge multe dintre acele detalii mai mici.

Acela a fost primul moment în care mi-am dat seama că acest model ar putea fi deosebit de bun pentru sarcini de programare în care îi oferi puțină libertate, mai degrabă decât să specifici fiecare detaliu de implementare.

Conectarea Qwen3.8-Flash-Next la OpenCode

Chat-ul e plăcut, dar eu am vrut în principal să testez Qwen3.8-Flash-Next ca model de coding agentic.

Pentru asta am folosit OpenCode. Instalează-l mai întâi:

curl -fsSL https://opencode.ai/install | bash

Repornește terminalul și verifică instalarea:

opencode --version

În cazul meu, era versiunea 1.18.23.

Acum creează configurația OpenCode:

mkdir -p ~/.config/opencode

Adaugă providerul local llama.cpp pe care l-am construit mai devreme:

printf '%s\n' '{"$schema":"https://opencode.ai/config.json","model":"llama.cpp/qwen3.8-flash-next","provider":{"llama.cpp":{"npm":"@ai-sdk/openai-compatible","name":"Qwen3.8 Flash Next Local","options":{"baseURL":"http://127.0.0.1:8080/v1"},"models":{"qwen3.8-flash-next":{"name":"Qwen3.8 Flash Next","limit":{"context":65536,"output":32768}}}}}}' > ~/.config/opencode/opencode.json

Cea mai importantă parte este http://127.0.0.1:8080/v1. 

OpenCode suportă provideri OpenAI-compatibili personalizați prin @ai-sdk/openai-compatible, ceea ce face conexiunea cu llama.cpp foarte ușoară.

Am setat OpenCode la un context de lucru de 65K, chiar dacă serverul llama.cpp are disponibil 131K.

Asta lasă suficient spațiu pentru outputuri lungi și împiedică sesiunile agentului să umple prea agresiv întregul context al serverului.

Folosirea Qwen3.8-Flash-Next ca agent local de programare

Navighează într-un director de proiect și pornește OpenCode:

cd /workspace/my-project
opencode

Acum poți da modelului sarcini agentice normale de programare. De exemplu, i-am spus lui Qwen să construiască un dashboard de analytics:

Build a modern system analytics and task-management dashboard. 
It should monitor CPU, RAM, VRAM, GPU usage, temperatures, disk usage, running processes, and temporary files. 
Users should be able to safely terminate tasks, free unused RAM/VRAM, clear caches, and clean temporary files from one interface.

Modelul a început prin a crea o listă de to-do și a planifica aplicația înainte de a scrie efectiv totul.

În câteva minute, a produs primul dashboard funcțional. Primul UI nu mi-a plăcut prea mult. Părea prea aerisit și erau câteva probleme de uzabilitate.

Așa că i-am spus pur și simplu agentului ce nu mi-a plăcut și i-am cerut să reconstruiască interfața într-un comand center de sistem mai compact.

A doua versiune a fost mult mai bună.

Am ajuns la un dashboard compact unde puteam monitoriza în timp real utilizarea CPU, RAM, VRAM, GPU, stocarea, activitatea de rețea și procesele în execuție. A adăugat, de asemenea, controale pentru curățarea cache-urilor, ștergerea fișierelor temporare și gestionarea proceselor.

Partea interesantă a fost modul în care Qwen a abordat implementarea. L-am testat pe două aplicații diferite și adesea a preferat HTML, CSS și JavaScript vanilla simple în loc să instaleze imediat React, pachete Node sau un alt framework mare.

Mi-a plăcut de fapt acest comportament. Dacă nu specificam un framework, încerca să găsească cea mai simplă arhitectură care rezolva problema, în loc să adauge dependențe inutile.

Dezavantajul este că își ia timp. Există mult raționament, mulți tokeni generați și uneori destul de mult debugging. Simți clar cum modelul consumă tokeni gândindu-se la problemă.

Dar proiectele finale păreau, în general, mult mai complete decât ceea ce obțin de obicei de la modele locale mai mici.

Gânduri finale

După ce am testat Qwen3.8-Flash-Next pentru generare de site-uri și coding agentic, cred că este un pas clar înainte față de Qwen3.8-27B. Cea mai mare diferență este modul în care abordează proiectele. Acordă mai multă atenție structurii, detaliilor și implementării practice, în loc să genereze doar cod. Dacă ești interesat să rulezi acest model local, citește tutorialul nostru Qwen3.8-27B.

Mi-a plăcut și faptul că se baza adesea pe HTML, CSS, JavaScript și Python simple, în loc să adauge framework-uri și dependențe inutile.

Principalul dezavantaj este dimensiunea. GGUF-ul UD-Q4_K_XL are în jur de 111GB, iar modelul poate folosi mult raționament și mulți tokeni de ieșire, mai ales în timpul debugging-ului.

În rest, setup-ul a fost surprinzător de simplu. Dacă ai suficientă RAM și VRAM, Qwen3.8-Flash-Next este unul dintre cele mai puternice modele locale de programare pe care le-am testat până acum.