Cara Menjalankan Qwen3.8-Flash-Next secara Lokal sebagai Agen Koding dengan OpenCode

Arsitektur Qwen3.8-Flash-Next

Ini adalah model MoE utama dengan 125 miliar parameter, namun hanya sekitar 6 miliar parameter yang diaktifkan per token. Model ini juga mencakup tambahan 51 miliar parameter dalam embedding n-gram.

Arsitekturnya memperkenalkan beberapa ide yang dieksplorasi Qwen untuk Qwen4:

• Gated DeltaNet + Qwen Sparse Attention (QSA) untuk pemrosesan konteks panjang yang lebih efisien
• Koneksi Residual Bertingkat (Gated Residual) untuk meningkatkan aliran informasi antar layer
• Embedding n-gram yang menambah kapasitas model tanpa mengharuskan semua parameter tersebut dihitung secara aktif

Sumber: Qwen 

Model ini memiliki panjang jendela konteks native sebesar 262.144 token dan secara teoretis dapat diperpanjang hingga 1 juta token menggunakan YaRN.

Bagaimana performa Qwen3.8-Flash-Next untuk koding?

Model ini juga mengejutkan karena kuat untuk koding. Berikut beberapa hasil yang dilaporkan Qwen dibandingkan dengan Qwen3.8-27B:

Ini adalah evaluasi internal Qwen, jadi tetap saya perlakukan sebagai hasil yang dilaporkan vendor, namun cukup selaras dengan pengalaman saya menggunakan model ini untuk koding.

Menyiapkan Server GPU untuk Qwen3.8-Flash-Next

Saya menggunakan RTX PRO 6000 dengan VRAM 96GB, tetapi Anda tidak harus memiliki VRAM sebesar itu.

Ini sebenarnya salah satu hal menarik dari Qwen3.8-Flash-Next. Karena llama.cpp dapat meng-offload sebagian model ke RAM sistem, Anda bisa menggunakan GPU dengan VRAM lebih kecil asalkan memiliki RAM yang banyak.

Kuantisasi Unsloth UD-Q4_K_XL yang kita gunakan berukuran sekitar 111GB dan dibagi ke dalam empat file GGUF.

Untuk setup saya, saya merekomendasikan memiliki setidaknya 140GB RAM dan VRAM gabungan yang dapat digunakan untuk memastikan cukup ruang bagi model, konteks, KV cache, dan overhead runtime.

Jika Anda punya sesuatu seperti H200, Anda bisa menaruh hampir semuanya di GPU. Saya memilih jalan tengah.

Mulai dengan memeriksa GPU Anda:

nvidia-smi

Anda seharusnya melihat GPU, versi driver, versi CUDA, dan VRAM yang tersedia.

Selanjutnya, instal paket yang diperlukan:

sudo apt update

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

Membangun llama.cpp dengan Dukungan Qwen3.8-Flash-Next

Qwen3.8-Flash-Next menggunakan arsitektur baru qwen4_exp, yang sangat berbeda dibanding sekadar memuat model Qwen3.8 lainnya.

Dukungan masih sangat baru, jadi saya menggunakan branch Qwen3.8-Flash-Next yang dikelola oleh Unsloth alih-alih mengandalkan build llama.cpp yang lebih lama yang mungkin tidak mengenali arsitekturnya. Pekerjaan terkait llama.cpp tersebut menambahkan arsitektur baru qwen4exp, QSA, embedding n-gram, dan komponen spesifik model lainnya.

Masuk ke workspace:

cd /workspace

Clone branch Unsloth:

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

Masuk ke direktori:

cd llama.cpp

Bangun llama.cpp dengan CUDA:

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

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

Terakhir, pastikan llama-server dibangun dengan benar:

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

Build saya menampilkan:

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

Mengunduh Model GGUF Qwen3.8-Flash-Next

Mengunduh model sebenarnya menjadi salah satu bagian yang paling menyebalkan dari setup ini.

Saya pertama mencoba ModelScope, tetapi kecepatannya tidak bagus. Di Hugging Face, unduhan awalnya mencapai kecepatan yang lumayan lalu tiba-tiba turun ke tingkat KB/detik.

Hugging Face kini menggunakan backend Xet untuk unduhan model besar dan biasanya mengaktifkan adaptive concurrency secara otomatis. Ia juga menyediakan HF_HUB_DISABLE_XET untuk menonaktifkan Xet ketika menimbulkan masalah.

Dalam kasus saya, menonaktifkan Xet dan mengunduh empat shard GGUF secara paralel jauh lebih efektif.

Instal CLI Hugging Face:

pip install -U huggingface_hub

Nonaktifkan Xet untuk unduhan ini:

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 kini sudah deprecated, karena Hugging Face memindahkan transfer besar ke Xet.

Buat direktori model:

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

Sekarang, unduh keempat shard secara 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

Kuant UD-Q4_K_XL lengkap berukuran sekitar 111GB.

Menjalankan Qwen3.8-Flash-Next dengan llama.cpp

Kembali ke direktori llama.cpp:

cd /workspace/llama.cpp

Mulai server:

./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

Saya sengaja menggunakan jendela konteks 131.072 token alih-alih konteks native penuh 262K.

Untuk agen koding, 131K sudah sangat besar dan memberi OpenCode banyak ruang untuk berkas sumber, output tool, log terminal, dan percakapan panjang tanpa membuang lebih banyak memori pada konteks yang mungkin tidak akan saya gunakan.

Pengaturan penting di sini adalah:

1. --fit on membuat llama.cpp secara otomatis menentukan seberapa banyak bagian model yang harus disimpan di GPU.

2. --fit-target 4096 memintanya untuk menyisakan sekitar 4GB memori GPU kosong, yang memberi ruang bernapas bagi runtime alih-alih berjalan tepat di batas VRAM. llama.cpp secara resmi mendukung fitting otomatis dan margin memori target yang dapat dikonfigurasi.

3. Pengaturan sampling juga bukan asal. Qwen merekomendasikan temperature=1.0, top_p=0.95, top_k=20, dan min_p=0.0 saat menggunakan model dalam mode thinking.

Bahkan setelah memuat model penuh, saya masih memiliki banyak memori tersisa, dengan sekitar 13GB VRAM tersedia untuk jendela konteks, KV cache, dan aplikasi lain.

Menguji Server Qwen3.8-Flash-Next Menggunakan CURL

llama-server mengekspos API yang kompatibel dengan OpenAI.

Periksa model yang tersedia:

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

Anda seharusnya melihat qwen3.8-flash-next.

Sekarang, mari uji pembuatan jawaban:

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."
      }
    ]
  }'

Jika Anda mendapatkan respons yang valid, server lokal siap digunakan.

Pada setup saya, awalnya saya melihat sekitar 80 token per detik, yang mengejutkan, mengingat sebagian model berada di RAM sistem.

Saat konteks menjadi lebih besar, kecepatannya turun mendekati 64 token per detik.

Itu tetap sangat bisa digunakan untuk model sebesar ini, dan arsitektur membantu menjelaskan alasannya. Walaupun model memiliki 125 miliar parameter utama, hanya sekitar 6 miliar yang aktif per token.

Menguji Qwen3.8-Flash-Next dengan WebUI llama.cpp

Satu hal yang saya suka dari llama.cpp adalah llama-server sudah menyediakan WebUI sederhana.

Buka http://localhost:8080. Jika semuanya berjalan dengan benar, model seharusnya sudah tersedia.

Untuk uji pertama yang serius, saya memintanya membangun situs web lengkap departemen TI pemerintahan dalam sekali jalan:

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, 

Ini adalah generasi yang cukup besar. Model menghabiskan banyak token untuk berpikir, lalu menghasilkan satu situs web lengkap dalam satu berkas HTML. Waktunya sekitar 13 menit untuk selesai, dan kecepatan generasi menurun bertahap seiring konteks bertambah.

Namun hasilnya jauh lebih baik dari yang saya perkirakan.

Terdapat chart, animasi, tab, berbagai section, styling responsif, interaksi JavaScript, dan tata letak keseluruhan yang mengejutkan rapi.

Yang menarik, ini pada dasarnya adalah generasi one-shot. Saya tidak secara eksplisit memintanya menambahkan banyak detail kecil tersebut.

Di titik itulah saya menyadari model ini mungkin sangat bagus untuk tugas koding ketika Anda memberinya sedikit kebebasan alih-alih menentukan setiap detail implementasi.

Menghubungkan Qwen3.8-Flash-Next ke OpenCode

Ngobrol itu bagus, tetapi saya terutama ingin menguji Qwen3.8-Flash-Next sebagai model koding agentik.

Untuk itu, saya menggunakan OpenCode. Instal terlebih dahulu:

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

Restart terminal Anda dan periksa instalasinya:

opencode --version

Dalam kasus saya, itu versi 1.18.23.

Sekarang buat konfigurasi OpenCode:

mkdir -p ~/.config/opencode

Tambahkan penyedia lokal llama.cpp yang kita bangun sebelumnya:

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

Bagian paling penting adalah http://127.0.0.1:8080/v1. 

OpenCode mendukung penyedia OpenAI-compatible kustom melalui @ai-sdk/openai-compatible, yang membuat llama.cpp sangat mudah dihubungkan.

Saya menetapkan OpenCode pada konteks kerja 65K meskipun server llama.cpp sendiri memiliki 131K tersedia.

Ini menyisakan banyak ruang untuk output panjang dan mencegah sesi agen terlalu agresif memenuhi seluruh konteks server.

Menggunakan Qwen3.8-Flash-Next sebagai Agen Koding Lokal

Arahkan ke direktori proyek dan jalankan OpenCode:

cd /workspace/my-project
opencode

Sekarang Anda dapat memberi model tugas koding agentik biasa. Misalnya, saya meminta Qwen membangun dashboard analitik:

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.

Model memulai dengan membuat daftar tugas dan merencanakan aplikasi sebelum menulis semuanya.

Dalam beberapa menit, ia menghasilkan dashboard kerja pertama. Saya kurang menyukai UI awal. Terasa terlalu renggang, dan ada beberapa masalah kegunaan.

Jadi saya cukup memberi tahu agen apa yang saya tidak suka dan memintanya membangun ulang antarmuka menjadi pusat kendali sistem yang lebih ringkas.

Versi kedua jauh lebih baik.

Akhirnya saya mendapatkan dashboard ringkas tempat saya dapat memantau CPU, RAM, VRAM, penggunaan GPU, penyimpanan, aktivitas jaringan, dan proses yang berjalan secara real time. Ia juga menambahkan kontrol untuk menghapus cache, membersihkan berkas sementara, dan mengelola proses.

Yang menarik adalah cara Qwen mendekati implementasi. Saya mengujinya pada dua aplikasi berbeda, dan sering kali ia memilih HTML, CSS, dan JavaScript vanilla sederhana alih-alih langsung memasang React, paket Node, atau framework besar lainnya.

Saya justru menyukai perilaku ini. Jika saya tidak menentukan framework, ia mencoba mencari arsitektur paling sederhana yang menyelesaikan masalah alih-alih menambah dependensi yang tidak perlu.

Kekurangannya adalah memakan waktu. Ada banyak penalaran, banyak token yang dihasilkan, dan terkadang cukup banyak debugging. Anda jelas bisa merasakan model menghabiskan token untuk memikirkan masalah.

Namun proyek akhir umumnya terasa jauh lebih lengkap dibanding yang biasanya saya dapatkan dari model lokal yang lebih kecil.

Pemikiran Akhir

Setelah menguji Qwen3.8-Flash-Next untuk pembuatan situs web dan koding agentik, saya rasa ini jelas satu tingkat di atas Qwen3.8-27B. Perbedaan terbesar adalah cara ia mendekati proyek. Ia lebih memperhatikan struktur, detail, dan implementasi praktis alih-alih sekadar menghasilkan kode. Jika Anda tertarik menjalankan model ini secara lokal, baca tutorial Qwen3.8-27B kami.

Saya juga menyukai bahwa ia sering mengandalkan HTML, CSS, JavaScript, dan Python sederhana alih-alih menambah framework dan dependensi yang tidak perlu.

Kekurangan utama adalah ukuran. GGUF UD-Q4_K_XL sekitar 111GB, dan model bisa menggunakan banyak token penalaran dan output, terutama saat debugging.

Selain itu, setupnya ternyata cukup lugas. Jika Anda memiliki cukup RAM dan VRAM, Qwen3.8-Flash-Next adalah salah satu model koding lokal terkuat yang pernah saya uji.