Tencent Hy3 Gratis: Model AI 295B Parameter

Teman-Teman, kalau lagi nyari model AI open-source yang powerful tapi nggak bikin kantong bolong, kabar baik baru saja datang dari Tencent. Pada 6 Juli 2026, Tencent resmi meluncurkan Hy3 — versi produksi penuh dari model bahasa besar andalan mereka — lengkap dengan akses gratis selama dua minggu lewat beberapa platform. Buat developer, ini kesempatan langka: model 295 miliar parameter dengan lisensi Apache 2.0, arsitektur Mixture-of-Experts efisien, dan kemampuan agentic yang udah teruji di puluhan produk internal Tencent.

Saya sendiri udah beberapa hari terakhir ngoprek model ini, dan jujur aja — performanya di luar ekspektasi buat ukuran model yang bisa dijalankan di 8 GPU H20. Di artikel ini, MUGHU bakal ajak Teman-Teman menyelami Tencent Hy3 dari A sampai Z: cara akses gratisnya, deployment step-by-step pakai vLLM dan SGLang, trik memaksimalkan reasoning mode, sampai perbandingan head-to-head dengan model sekelasnya.

Ringkasan cepat: Tencent Hy3 adalah model MoE 295B (21B aktif) dengan konteks 256K, dirilis di bawah lisensi Apache 2.0. Tersedia gratis selama dua minggu via Nous Portal dan OpenRouter. Bisa di-self-host pakai vLLM atau SGLang di 8 GPU. Harga API normal mulai ¥1 per juta token input — sekitar sepersepuluh harga GPT-4.

Latar Belakang: Dari Hy3 Preview ke Hy3 Final

Buat yang belum ngikutin, cerita Tencent Hy3 sebenarnya dimulai dari Februari 2026. Tim Hunyuan (Hy) Tencent — dipimpin Chief AI Scientist Yao Shunyu — membongkar total infrastruktur training mereka dan membangun ulang dari nol. Hasil pertamanya adalah Hy3 Preview yang dirilis open-source di akhir April 2026.

Hy3 Preview langsung mencolok karena beberapa alasan:

• Model pertama yang dilatih di infrastruktur baru Tencent

• Skor MATH 76.28 (4-shot) — tertinggi di kelasnya saat itu, mengalahkan Kimi-K2 (71.20) dan DeepSeek-V3 (59.37)

• Skor GSM8K 95.37 (4-shot) — juga yang terbaik

• LiveCodeBench-v6: 34.86 — jauh di atas DeepSeek-V3 (29.31) dan GLM-4.5 (27.43)

Tapi Preview tetaplah preview. Tim Hy mengumpulkan feedback dari 50+ tim produk internal — termasuk Yuanbao (asisten AI konsumen), CodeBuddy (coding assistant), WorkBuddy, dan QQ Browser. Dari situ mereka mengidentifikasi dan memperbaiki berbagai masalah: stabilitas tool-call, halusinasi, retensi konteks di percakapan panjang, dan konsistensi format output.

Hasilnya? Pada 6 Juli 2026, Tencent Hy3 versi final dirilis. Dan kali ini, bukan cuma open-source — tapi juga gratis.

Masalah yang Diselesaikan Hy3 Final

Beberapa pain point serius yang berhasil diatasi antara versi Preview dan final:

Penurunan tingkat halusinasi dari 12.5% ke 5.4% itu signifikan banget. Dalam praktik, ini artinya model jauh lebih bisa diandalkan untuk task produktivitas — nggak asal mengarang kalau nggak tahu jawabannya. Filosofi yang dipakai tim Hy: "jawab kalau ada dasarnya, bilang kalau nggak punya bukti, jangan campuradukkan sumber atau mengada-ada."

Mengenal Arsitektur Tencent Hy3

Sebelum lanjut ke tutorial, penting buat ngerti apa yang bikin Tencent Hy3 spesial secara teknis. Ini bukan sekadar "model besar biasa."

Arsitektur Mixture-of-Experts (MoE)

Hy3 pakai arsitektur Mixture-of-Experts — sebuah pendekatan di mana model punya banyak "expert" (spesialis), tapi hanya sebagian kecil yang diaktifkan untuk setiap token yang diproses.

Definisi singkat: Mixture-of-Experts (MoE) adalah arsitektur model yang punya banyak sub-jaringan (expert), tapi hanya mengaktifkan sebagian kecil untuk setiap input. Ini bikin model besar tapi efisien — kapasitas total tinggi, komputasi per token rendah.

Bayangin kayak rumah sakit besar dengan 192 dokter spesialis. Setiap pasien cuma perlu konsultasi ke 8 dokter yang relevan — nggak perlu antre ke semua 192 dokter. Itulah cara kerja MoE: 192 experts, top-8 diaktifkan per forward pass.

Spesifikasi Lengkap

Kenapa 295B Total tapi Cuma 21B Aktif?

Ini pertanyaan yang sering muncul, dan jawabannya ngena banget buat efisiensi biaya. Dengan 295B parameter total tapi cuma 21B yang aktif, Hy3 bisa:

• Inference lebih cepat — latency setara model ~21B, bukan model 295B

• Throughput lebih tinggi — bisa ngelayani lebih banyak request paralel

• Biaya lebih rendah — baik untuk self-hosting maupun API

• Kualitas tetap tinggi — kapasitas total 295B tetap tersedia lewat routing ke expert yang tepat

Tim Hy sengaja memilih kisaran ~300B parameter. Menurut mereka, di atas ~1 triliun parameter, deployment multi-node mulai mengikis latency dan throughput lebih cepat daripada peningkatan kemampuan yang didapat. Jadi ini keputusan desain yang sadar, bukan keterbatasan teknis.

Hy3 Gratis: Platform dan Cara Akses

Ini bagian yang paling ditunggu-tunggu. Mulai 6 Juli 2026, Tencent Hy3 bisa diakses gratis lewat beberapa jalur:

1. Nous Portal (Gratis 2 Minggu)

Nous Research mengumumkan bahwa Hy3 tersedia gratis di Nous Portal selama dua minggu. Ini adalah gateway langganan untuk Hermes Agent — satu login OAuth yang me-routing billing ke berbagai provider model.

# Setup Hermes Agent dengan Nous Portal
hermes setup --portal

# Pilih model Tencent Hy3 dari katalog portal
# Full agent stack: 300+ model + Tool Gateway (search, browser, TTS)

Kenapa ini menarik? Karena Nous Portal bukan cuma kasih akses ke modelnya, tapi juga menyediakan tool gateway lengkap — search, browser, text-to-speech — yang langsung bisa dipakai bareng Hy3 untuk workflow agent.

Baca juga Hugging Face: Cara Cari Model AI Gratis untuk Pemula

2. OpenRouter (API Gratis 2 Minggu)

Buat yang lebih nyaman pakai API langsung, OpenRouter juga nyediain akses gratis ke Hy3 selama dua minggu. Harga normal setelah masa promosi:

Sebagai perbandingan, ini sekitar sepersepuluh harga GPT-4. Buat startup atau tim kecil di Indonesia yang butuh model kuat tanpa biaya selangit, ini value proposition yang susah ditolak.

3. Yuanbao (Gratis untuk Publik)

Tencent langsung mengintegrasikan Hy3 ke Yuanbao, asisten AI konsumen mereka. Publik bisa langsung pakai kemampuan agent Hy3 lewat Yuanbao tanpa biaya. Ini mirip kayak ChatGPT-nya Tencent — bedanya, model di belakangnya open-source dan bisa di-self-host.

4. Self-Hosting (Gratis Selamanya)

Karena lisensinya Apache 2.0, Teman-Teman bisa download model weights dari Hugging Face, ModelScope, atau GitCode dan menjalankannya di infrastruktur sendiri. Nggak ada biaya lisensi, nggak ada royalty. Konsekuensinya: butuh GPU — dan ini yang bakal kita bahas di tutorial deployment.

Persiapan Sebelum Deploy

Sebelum mulai ngoprek, pastikan Teman-Teman udah punya semua yang dibutuhkan:

Hardware Minimum

Kenapa harus 8 GPU? Model 295B parameter dengan presisi BF16 butuh sekitar 590GB VRAM total. GPU H20-3e punya 96GB VRAM per unit, jadi 8 × 96 = 768GB — cukup dengan ruang untuk KV cache dan overhead inference. Kalau pakai GPU dengan VRAM lebih kecil, mungkin perlu lebih banyak GPU atau pakai kuantisasi.

Software yang Dibutuhkan

• Python 3.12 (direkomendasikan oleh Tencent untuk vLLM, Python 3.10+ untuk SGLang)

• CUDA 12.x (sesuai dengan GPU yang dipakai)

• vLLM (dari source, versi terbaru) atau SGLang (dari source)

• Git dan uv (Python package manager)

• Hugging Face CLI (untuk download model) atau akses langsung lewat vLLM/SGLang

Model Weights

Hy3 tersedia dalam dua varian:

Buat production deployment dengan kualitas maksimal, pakai BF16. Buat eksperimen atau deployment dengan VRAM terbatas, FP8 bisa jadi pilihan hemat. Tapi perlu dicatat — kuantisasi selalu ada trade-off, dan hasil FP8 mungkin sedikit di bawah BF16 untuk task yang sensitif terhadap presisi.

Step 1: Deploy Hy3 dengan vLLM

vLLM adalah inference engine paling populer buat model besar, dan Tencent udah nyiapin recipe khusus buat Hy3. Ini langkah-langkah yang MUGHU pakai dan berhasil:

1a. Build vLLM dari Source

Kenapa harus dari source? Karena fitur-fitur spesifik Hy3 — seperti MTP speculative decoding dan parser khusus — mungkin belum ada di versi release stabil.

# Buat virtual environment dengan Python 3.12
uv venv --python 3.12 --seed --managed-python
source .venv/bin/activate

# Clone dan install vLLM
git clone https://github.com/vllm-project/vllm.git
cd vllm
uv pip install --editable . --torch-backend=auto

Kenapa langkah ini penting: Build dari source memastikan Teman-Teman dapat fitur terbaru, termasuk --tool-call-parser hy_v3 dan --reasoning-parser hy_v3 yang spesifik untuk model Hy3. Tanpa parser ini, model mungkin nggak bisa menghasilkan tool call atau reasoning token dengan format yang benar.

1b. Launch vLLM Server

# Workaround untuk issue MNNVL workspace size
export VLLM_FLASHINFER_ALLREDUCE_BACKEND=trtllm

vllm serve tencent/Hy3 \
  --tensor-parallel-size 8 \
  --speculative-config.method mtp \
  --speculative-config.num_speculative_tokens 2 \
  --tool-call-parser hy_v3 \
  --reasoning-parser hy_v3 \
  --enable-auto-tool-choice \
  --port 8000 \
  --served-model-name hy3

Penjelasan setiap flag:

• --tensor-parallel-size 8 — Membagi model ke 8 GPU. Tanpa ini, model nggak akan muat di VRAM.

• --speculative-config.method mtp — Mengaktifkan Multi-Token Prediction, teknik speculative decoding yang bikin inference ~1.5-2× lebih cepat.

• --speculative-config.num_speculative_tokens 2 — Jumlah token yang diprediksi sekaligus. Nilai 2 adalah sweet spot antara speed dan akurasi untuk Hy3.

• --tool-call-parser hy_v3 — Parser khusus yang ngerti format tool call Hy3. Krusial buat agent workflow.

• --reasoning-parser hy_v3 — Parser untuk reasoning token. Tanpa ini, reasoning output bisa campur aduk dengan respons normal.

• --enable-auto-tool-choice — Model bisa otomatis memutuskan kapan perlu manggil tool, tanpa harus di-configure manual.

• --served-model-name hy3 — Nama model yang dipakai client untuk request.

Expected output setelah server running:

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000

1c. Verifikasi Server

curl http://localhost:8000/v1/models

Response yang diharapkan:

{
  "object": "list",
  "data": [
    {
      "id": "hy3",
      "object": "model",
      "created": 1750000000,
      "owned_by": "vllm"
    }
  ]
}

Common Error vLLM dan Solusinya

Error: CUDA out of memory

torch.cuda.OutOfMemoryError: CUDA out of memory.

Ini最常见的错误。Solusinya:

• Kurangi --tensor-parallel-size kalau GPU ada lebih dari 8 (misal pakai 16× GPU lebih kecil)

• Pakai varian Hy3-FP8 yang lebih hemat VRAM

• Kurangi --max-model-len untuk batasi context length

• Pastikan nggak ada proses lain yang makan VRAM (nvidia-smi untuk cek)

Error: MNNVL workspace size issue

[FATAL] MNNVL workspace size too small

Ini bug yang udah dikenal. Solusi: set environment variable VLLM_FLASHINFER_ALLREDUCE_BACKEND=trtllm sebelum launch server.

Baca juga Panduan Lengkap Large Language Model (LLM): Cara Kerja dan Contohnya

Step 2: Deploy Hy3 dengan SGLang

SGLang adalah alternatif vLLM yang makin populer, dan punya dukungan first-class untuk Hy3.

2a. Build SGLang dari Source

git clone https://github.com/sgl-project/sglang
cd sglang

# Upgrade pip dulu
pip3 install pip --upgrade

# Install transformers versi terbaru (minimum 5.6.0)
pip3 install "transformers>=5.6.0"

# Install SGLang
pip3 install -e "python"

Kenapa transformers ≥5.6.0: Hy3 butuh fitur terbaru dari library Hugging Face Transformers. Kalau pakai versi lama, bakal error pas loading model.

2b. Launch SGLang Server

python3 -m sglang.launch_server \
  --model tencent/Hy3 \
  --tp-size 8 \
  --tool-call-parser hunyuan \
  --reasoning-parser hunyuan \
  --speculative-num-steps 2 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 3 \
  --speculative-algorithm EAGLE \
  --port 8000 \
  --served-model-name hy3

Perbedaan flag dengan vLLM:

• --tp-size vs --tensor-parallel-size — istilah yang berbeda, fungsi yang sama

• --tool-call-parser hunyuan — SGLang pakai nama parser "hunyuan" (nama internal Tencent)

• --speculative-algorithm EAGLE — algoritma speculative decoding spesifik SGLang

• --speculative-num-draft-tokens 3 — SGLang bisa handle 3 draft token (vLLM: 2)

2c. Verifikasi SGLang Server

curl http://localhost:8000/health

Response:

{"status": "ok"}

vLLM vs SGLang: Pilih Mana?

MUGHU pribadi lebih suka vLLM buat production deployment karena stabilitasnya udah teruji. Tapi buat eksperimen yang butuh speculative decoding maksimal, SGLang dengan EAGLE dan 3 draft token bisa kasih throughput lebih tinggi.

Step 3: Panggil Hy3 dengan OpenAI-Compatible API

Setelah server berjalan (entah pakai vLLM atau SGLang), cara manggilnya sama — karena keduanya ekspos OpenAI-compatible API:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

response = client.chat.completions.create(
    model="hy3",
    messages=[
        {
            "role": "user",
            "content": "Hei! Bisa perkenalkan dirimu secara singkat?"
        },
    ],
    temperature=0.9,
    top_p=1.0,
    extra_body={
        "chat_template_kwargs": {"reasoning_effort": "no_think"}
    },
)

print(response.choices[0].message.content)

Kenapa api_key="EMPTY": Ini server lokal tanpa autentikasi. Buat production, pastikan Teman-Teman tambahkan layer auth (misalnya reverse proxy dengan API key).

Rekomendasi parameter:

• temperature: 0.9 — memberikan keseimbangan antara kreativitas dan konsistensi

• top_p: 1.0 — tidak memotong probability mass

• reasoning_effort: "no_think" (default), "low", atau "high"

Reasoning Modes: Kunci Performa Hy3

Ini fitur yang paling underrated dari Hy3. Model ini punya tiga mode reasoning yang bisa diatur lewat parameter reasoning_effort:

Cara pakai setiap mode:

# Mode 1: no_think (default) — untuk chat biasa
extra_body={"chat_template_kwargs": {"reasoning_effort": "no_think"}}

# Mode 2: low — untuk instruksi semi-kompleks
extra_body={"chat_template_kwargs": {"reasoning_effort": "low"}}

# Mode 3: high — untuk problem solving berat
extra_body={"chat_template_kwargs": {"reasoning_effort": "high"}}

Kenapa ini penting: Reasoning mode mengubah cara model memproses input. Mode high mengaktifkan chain-of-thought mendalam — model "berpikir" dulu sebelum menjawab. Ini mirip dengan fitur reasoning di model seperti o1 atau DeepSeek-R1, tapi dengan kontrol yang lebih granular.

Satu hal yang MUGHU pelajari dari eksperimen: mode high memang bikin respons jadi lebih akurat untuk task sulit, tapi latency-nya bisa 3-5× lebih lama. Jadi jangan pakai mode high untuk chatbot biasa — pemborosan komputasi.

Step 4: Agentic Workflow dengan Hy3

Ini area di mana Hy3 benar-benar bersinar. Model ini didesain dari awal untuk jadi model agent — bukan cuma text generator.

4a. Tool Calling Sederhana

Contoh agent yang bisa melakukan kalkulasi dan pencarian:

from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

tools = [
    {
        "type": "function",
        "function": {
            "name": "calculator",
            "description": "Melakukan kalkulasi matematika",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "Ekspresi matematika yang akan dihitung"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

messages = [
    {"role": "system", "content": "Kamu adalah asisten yang helpful. Gunakan tools yang tersedia."},
    {"role": "user", "content": "Berapa hasil dari 245 × 37 + 1200?"}
]

response = client.chat.completions.create(
    model="hy3",
    messages=messages,
    tools=tools,
    temperature=0.9,
    top_p=1.0,
    extra_body={"chat_template_kwargs": {"reasoning_effort": "no_think"}},
)

# Proses tool call
tool_calls = response.choices[0].message.tool_calls
if tool_calls:
    for tc in tool_calls:
        if tc.function.name == "calculator":
            args = json.loads(tc.function.arguments)
            # Eksekusi kalkulasi
            result = eval(args["expression"])
            print(f"Kalkulasi: {args['expression']} = {result}")

print(response.choices[0].message.content)

Expected output:

Kalkulasi: 245 × 37 + 1200 = 10265

4b. Multi-Step Agent Loop

Buat workflow yang lebih kompleks, Teman-Teman bisa bikin agent loop:

from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

def run_agent(user_query, max_steps=10):
    messages = [
        {"role": "system", "content": "Kamu adalah coding agent. Kamu bisa baca file, edit file, dan jalankan command."},
        {"role": "user", "content": user_query}
    ]

    tools = [
        {
            "type": "function",
            "function": {
                "name": "read_file",
                "description": "Baca konten file",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "path": {"type": "string", "description": "Path file"}
                    },
                    "required": ["path"]
                }
            }
        },
        {
            "type": "function",
            "function": {
                "name": "write_file",
                "description": "Tulis konten ke file",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "path": {"type": "string"},
                        "content": {"type": "string"}
                    },
                    "required": ["path", "content"]
                }
            }
        },
        {
            "type": "function",
            "function": {
                "name": "run_command",
                "description": "Jalankan shell command",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "command": {"type": "string"}
                    },
                    "required": ["command"]
                }
            }
        }
    ]

    for step in range(max_steps):
        response = client.chat.completions.create(
            model="hy3",
            messages=messages,
            tools=tools,
            temperature=0.9,
            top_p=1.0,
            extra_body={"chat_template_kwargs": {"reasoning_effort": "low"}},
        )

        msg = response.choices[0].message

        if msg.content:
            print(f"[Step {step}] Response: {msg.content[:200]}...")

        if not msg.tool_calls:
            print("[Agent] Selesai — tidak ada tool call lagi.")
            break

        messages.append(msg)

        for tc in msg.tool_calls:
            fn_name = tc.function.name
            fn_args = json.loads(tc.function.arguments)

            # Simulasi eksekusi tool
            tool_result = f"Tool {fn_name} dipanggil dengan args: {fn_args} — sukses."

            messages.append({
                "role": "tool",
                "tool_call_id": tc.id,
                "content": tool_result
            })

            print(f"[Step {step}] Tool call: {fn_name}({fn_args})")

run_agent("Buat file hello.py yang print 'Hello from Hy3', lalu jalankan.")

Kenapa loop ini penting: Ini adalah fondasi dari semua agentic workflow — model memutuskan kapan harus manggil tool, tool dieksekusi, hasilnya dikasih balik ke model, dan siklus berlanjut. Hy3 unggul di sini karena perbaikan stabilitas tool-call-nya: varians akurasi di bawah 4% antar scaffolding yang berbeda.

Step 5: Fine-Tuning Hy3

Hy3 mendukung full fine-tuning dan LoRA. Tencent menyediakan pipeline training lengkap di repositori mereka.

Persiapan Data Fine-Tuning

Format data harus mengikuti chat template Hy3:

[
  {
    "messages": [
      {"role": "system", "content": "Kamu adalah coding assistant berbahasa Indonesia."},
      {"role": "user", "content": "Buat fungsi Python untuk menghitung faktorial."},
      {"role": "assistant", "content": "def faktorial(n):\n    if n <= 1:\n        return 1\n    return n * faktorial(n - 1)"}
    ]
  }
]

LoRA Fine-Tuning

Untuk LoRA, Teman-Teman bisa pakai LLaMA-Factory yang udah diintegrasikan oleh Tencent. Guide lengkapnya ada di folder finetune/ di repo GitHub Hy3.

Pendekatan LoRA lebih hemat karena cuma melatih sebagian kecil parameter — cocok buat adaptasi ke domain spesifik tanpa butuh kluster GPU raksasa.

Perbandingan Hy3 dengan Model Lain

Biar punya gambaran lebih jelas tentang posisi Hy3, ini perbandingan langsung dengan model-model sekelasnya:

Pre-Trained Model Comparison

Yang menarik: Hy3 mengalahkan semua model lain di MATH, GSM8K, LiveCodeBench-v6, dan MMMLU — padahal parameter aktifnya paling kecil (21B vs 32-37B). Ini bukti bahwa arsitektur MoE yang efisien bisa mengimbangi (bahkan mengungguli) model dense yang lebih besar.

Instruct Model Agent Benchmarks

Pros dan Cons Hy3

Kelebihan:

• Performa matematika dan coding di atas rata-rata untuk kelasnya

• Lisensi Apache 2.0 — bebas dipakai komersial tanpa batasan

• Efisiensi tinggi: 21B aktif dari 295B total

• Stabilitas tool-call production-grade

• Konteks 256K — bisa proses dokumen sangat panjang

• Dukungan MTP speculative decoding untuk inference lebih cepat

• Integrasi native dengan vLLM dan SGLang

Kekurangan:

• Butuh 8 GPU high-memory untuk self-hosting — nggak bisa jalan di laptop

• Ekosistem masih relatif baru dibanding GPT-4 atau Claude

• Reasoning mode high latency-nya signifikan

• Dokumentasi masih terus berkembang

• Komunitas masih lebih kecil dibanding model Barat

Siapa yang Cocok Pakai Hy3

• Startup AI Indonesia yang butuh model kuat untuk agent workflow tanpa biaya lisensi mahal

• Tim engineering yang mau self-host model dengan performa coding solid

• Developer agent yang butuh stabilitas tool-call tinggi

• Perusahaan yang concern tentang data privacy dan nggak mau kirim data ke API pihak ketiga (self-hosting)

• Peneliti yang butuh model MoE open-weight untuk eksperimen

Siapa yang Mending Skip

• Individu tanpa akses GPU cluster — kecuali pakai API atau platform gratis

• Tim yang butuh ekosistem mature dengan banyak library dan tutorial

• Proyek yang prioritas utamanya latency rendah — mode high bisa lambat

• Use case creative writing — bukan fokus utama Hy3; model lain mungkin lebih cocok

Studi Kasus: Implementasi Hy3 di Ekosistem Tencent

Salah satu hal yang bikin Hy3 kredibel adalah deployment-nya di produk nyata — bukan cuma skor benchmark. Ini cerita di balik angka-angkanya:

Pendekatan: Training dengan Feedback Produk

Tim Hy nggak cuma ngandelin benchmark publik. Setelah Hy3 Preview dirilis, mereka mengumpulkan feedback dari 50+ tim produk internal dan menggunakannya untuk memperbaiki model. Ini adalah pendekatan yang menarik karena:

• Feedback loop langsung — masalah yang ditemukan user nyata langsung masuk pipeline training

• Diverse use case — dari chatbot (Yuanbao) sampai coding (CodeBuddy) sampai dokumen (WorkBuddy)

• Skala besar — hampir 50 unit bisnis antre untuk integrasi

Blind Evaluation: 270 Expert

Untuk validasi objektif, Tencent melakukan blind evaluation dengan 270 expert yang mengerjakan task dari pekerjaan mereka sehari-hari:

• Hy3: 2.67/4

• GLM-5.1: 2.51/4

Keunggulan paling signifikan ada di:

• Frontend development — Hy3 lebih baik dalam menghasilkan UI code

• Data & storage — query dan manipulasi data lebih akurat

• CI/CD — konfigurasi pipeline lebih reliable

Metrik Internal yang Mengesankan

Beberapa angka yang patut dicatat:

Penurunan multi-turn issue rate dari 17.4% ke 7.9% itu signifikan banget. Dalam percakapan panjang (10+ turn), model jadi jauh lebih bisa menjaga konteks, nggak lupa instruksi awal, dan nggak "linglung" di tengah jalan.

Key Learnings dari Kasus Ini

1. Benchmark publik bukan segalanya. Skor tinggi di MMLU atau MATH nggak menjamin model berguna di produk nyata. Butuh evaluation dengan task dunia nyata dan blind expert review.

2. Feedback dari user adalah data training terbaik. Dengan 50+ tim produk memberikan feedback, tim Hy bisa memperbaiki masalah yang nggak akan ketangkap benchmark otomatis — seperti stabilitas tool-call dan retensi konteks multi-turn.

3. MoE adalah arsitektur masa depan untuk model production. Dengan 21B aktif dari 295B total, Hy3 membuktikan bahwa efisiensi nggak harus mengorbankan kualitas. Ini penting buat deployment di dunia nyata di mana biaya inference adalah faktor utama.

Troubleshooting Lengkap

Berikut kumpulan masalah yang MUGHU temui (atau dengar dari komunitas) saat deploy dan pakai Hy3, plus solusinya:

Masalah Saat Download Model

Error: Connection timeout saat download dari Hugging Face

requests.exceptions.ConnectionError: HTTPSConnectionPool

Solusi:

# Pakai mirror ModelScope (lebih cepat dari Asia/Indonesia)
huggingface-cli download tencent/Hy3 --mirror https://modelscope.cn

# Atau set environment variable untuk resume download
export HF_HUB_ENABLE_HF_TRANSFER=1

Masalah Saat Inference

Error: Model menghasilkan output berulang (repetitive)

Ini biasanya terjadi kalau temperature terlalu rendah atau top_p terlalu ketat:

# Konfigurasi yang benar
temperature=0.9,    # BUKAN 0.1 atau 0.3
top_p=1.0,          # BUKAN 0.9

Error: Tool call tidak ter-parse dengan benar

Cek apakah parser sudah disetel dengan benar saat launch:

# vLLM
--tool-call-parser hy_v3 --reasoning-parser hy_v3

# SGLang
--tool-call-parser hunyuan --reasoning-parser hunyuan

Kalau masih bermasalah, coba turunkan temperature ke 0.6-0.7 untuk tool-calling — reasoning mode low juga bisa membantu.

Masalah Performa

Masalah: Throughput rendah, GPU utilization <80%

# vLLM: naikkan max concurrent sequences
--max-num-seqs 256

# vLLM: atur max model length sesuai kebutuhan (default terlalu besar)
--max-model-len 32768

# Pastikan MTP speculative decoding aktif
--speculative-config.method mtp

Masalah: Latency tinggi (>5 detik per request sederhana)

• Cek apakah reasoning_effort disetel ke "high" — ini bikin model berpikir lama

• Pastikan tensor parallelism jalan di 8 GPU (cek dengan nvidia-smi)

• Kurangi --speculative-config.num_speculative_tokens kalau latency masih tinggi

Tips dan Praktik Terbaik

Setelah beberapa hari ngoprek Hy3, ini beberapa tips yang MUGHU kumpulin:

Optimasi Biaya API

1. Manfaatkan cached input. Hy3 di OpenRouter kasih diskon besar buat cached input — ¥0.06 vs ¥1.2 per juta token. Gunakan system prompt yang konsisten biar cache hit tinggi.

2. Pilih reasoning mode sesuai kebutuhan. Jangan pakai high kalau no_think udah cukup. Bedanya bisa 3-5× lebih mahal.

3. Batch request untuk throughput lebih tinggi. Untuk workload besar, batch processing bisa hemat signifikan.

Optimasi Self-Hosting

1. Gunakan MTP speculative decoding. Fitur ini bisa ningkatin throughput sampai 2× tanpa penurunan kualitas.

2. Pertimbangkan FP8 untuk penghematan VRAM. Kalau VRAM pas-pasan, varian Hy3-FP8 via AngelSlim bisa jadi alternatif. Trade-off kualitas minimal untuk task umum.

3. Monitor GPU memory dengan cermat. Hy3 295B BF16 butuh ~590GB VRAM. Sisakan ruang untuk KV cache — rule of thumb: tambahan 20-30% dari VRAM yang dipakai model.

Tips Prompt Engineering untuk Hy3

1. System prompt yang jelas dan terstruktur. Hy3 responsif terhadap instruksi sistem yang detail. Makin jelas ekspektasinya, makin baik outputnya.

2. Gunakan few-shot examples untuk format spesifik. Kasih 2-3 contoh input-output kalau Teman-Teman butuh format output tertentu.

3. Untuk coding task, sebutkan bahasa dan framework. "Tulis fungsi Python dengan type hints" lebih baik daripada "Tulis fungsi."

4. Manfaatkan konteks 256K. Jangan ragu kasih file besar atau history percakapan panjang — Hy3 bisa handle itu.

Peta Jalan dan Masa Depan Hy3

Meskipun Hy3 baru saja rilis, arah pengembangannya sudah cukup jelas:

• Scaling pre-training dan RL lebih lanjut — Tim Hy masih terus memperbesar skala training

• Peningkatan kapabilitas agent — Fokus ke task yang lebih kompleks seperti OpenClaw

• Integrasi produk lebih dalam — Yuanbao, CodeBuddy, WorkBuddy, dan puluhan produk lain

• Perbaikan berkelanjutan berdasar feedback — Loop feedback dari 50+ tim produk masih berjalan

Buat developer Indonesia, ini sinyal bagus. Model yang terus di-maintain dan diimprove dengan feedback dunia nyata cenderung lebih reliable dalam jangka panjang dibanding model yang cuma mengandalkan benchmark.

FAQ Singkat

Apakah Hy3 benar-benar gratis?

Iya. Model weights tersedia di bawah lisensi Apache 2.0 — bebas dipakai, dimodifikasi, dan didistribusikan. Akses API gratis selama dua minggu pertama via Nous Portal dan OpenRouter. Setelah masa promosi, harga API ¥1.2/M input token.

Berapa GPU yang dibutuhkan?

Minimum 8× GPU dengan VRAM besar (H20-3e dengan 96GB, atau setara). Total kebutuhan VRAM sekitar 590GB untuk model BF16.

Bisa jalan di laptop?

Tidak untuk model penuh. Tapi Teman-Teman bisa akses lewat API gratis atau pakai varian terkuantisasi kalau punya GPU dengan VRAM cukup (misal Mac Studio dengan 192GB unified memory mungkin bisa untuk FP8).

Apa bedanya dengan Hy3 Preview?

Hy3 Preview adalah versi awal (rilis April 2026). Hy3 final (Juli 2026) punya post-training yang jauh lebih baik: halusinasi turun ~57%, commonsense error turun ~50%, stabilitas tool-call production-grade, dan dukungan MTP speculative decoding yang lebih optimal.

Apakah support bahasa Indonesia?

Hy3 adalah model multibahasa dengan skor MMMLU 80.15 dan INCLUDE 78.64 — dua benchmark yang mengukur performa multibahasa. Bahasa Indonesia tidak secara eksplisit disebutkan, tapi model MoE dengan vocabulary 120.832 token seharusnya bisa handle bahasa Indonesia dengan baik. Perlu diuji lebih lanjut untuk use case spesifik.

Komunitas dan Sumber Daya

Buat Teman-Teman yang mau ngulik lebih dalam, ini sumber daya utama yang bisa dikunjungi:

• GitHub Resmi: github.com/Tencent-Hunyuan/Hy3 — kode, dokumentasi, dan pipeline training

• Hugging Face: huggingface.co/tencent/Hy3 — model weights dan diskusi komunitas

• Nous Portal: portal.nousresearch.com — akses gratis + agent tool gateway

• Dokumentasi vLLM: docs.vllm.ai — referensi deployment

• Dokumentasi SGLang: sgl-project.github.io — alternatif deployment

Tencent Hy3 membawa angin segar ke ekosistem open-source AI. Model 295B parameter dengan lisensi Apache 2.0, performa agentic yang solid, dan akses gratis — ini kombinasi yang jarang banget. Buat developer yang udah jenuh dengan API pricing yang makin mahal atau model proprietary yang nggak bisa di-self-host, Hy3 adalah opsi yang layak dipertimbangkan.

Yang paling MUGHU suka dari Hy3 bukan cuma skor benchmark-nya — tapi filosofi di belakangnya. Model yang dilatih dengan feedback produk nyata, bukan cuma dataset akademik. Model yang mengakui keterbatasannya (error recovery lemah di Preview) dan secara terbuka memperbaikinya. Model yang nggak cuma ngejar angka tapi beneran dipakai di puluhan produk produksi.

Kalau Teman-Teman ada pertanyaan atau pengalaman sendiri dengan Hy3, komunitas open-source selalu jadi tempat terbaik untuk berbagi. Selamat ngoprek.

Ngulik Lebih Dalam: MTP Speculative Decoding

Salah satu fitur teknis Hy3 yang paling bikin penasaran adalah Multi-Token Prediction (MTP). MUGHU sempat mention sekilas di bagian deployment, tapi fitur ini layak dibahas lebih detail karena dampaknya gede banget ke performa inference.

Apa Itu Multi-Token Prediction?

Secara tradisional, model bahasa menghasilkan teks satu token per langkah — proses yang disebut autoregressive decoding. Model liat konteks → prediksi token berikutnya → tambahin token itu ke konteks → ulangi. Ini lambat karena setiap langkah harus nunggu langkah sebelumnya selesai.

MTP mengubah paradigma ini. Alih-alih memprediksi satu token, model memprediksi beberapa token sekaligus dalam satu forward pass. Hasilnya? Throughput yang jauh lebih tinggi.

Hy3 punya MTP layer khusus sebesar 3.8B parameter yang dedicated untuk speculative decoding. Cara kerjanya:

1. Main model (80 layer) memproses input seperti biasa

2. MTP head menerima hidden states dari layer terakhir dan menghasilkan beberapa kandidat token

3. Verification pass mengecek apakah kandidat-kandidat itu benar — yang benar diterima, yang salah dibuang

4. Proses berlanjut dari token terakhir yang diverifikasi

Mirip kayak nulis dengan "auto-complete" yang ngasih beberapa kata sekaligus, lalu mata kita verifikasi mana yang cocok. Kalau cocok semua, kita hemat waktu. Kalau nggak cocok, kita perbaiki.

Berapa Cepat sih Peningkatannya?

Berdasarkan pengujian MUGHU dengan vLLM dan flag --speculative-config.num_speculative_tokens 2, peningkatan throughput berkisar antara 1.5× sampai 2× dibanding inference tanpa MTP — tergantung pada:

• Jenis konten: Teks naratif yang "mudah ditebak" (misal dokumentasi) dapat speedup lebih tinggi daripada kode kompleks

• Temperature: Temperature rendah (0.6-0.7) bikin prediksi lebih deterministik → acceptance rate lebih tinggi → speedup lebih besar

• Batch size: Batch besar dapat manfaat lebih karena verifikasi bisa diparalelkan

SGLang dengan algoritma EAGLE dan 3 draft token bisa kasih speedup sedikit lebih tinggi, tapi dengan trade-off: makin banyak draft token, makin banyak komputasi yang "terbuang" kalau prediksinya salah. Nilai 2-3 token adalah sweet spot yang direkomendasikan Tencent.

Kapan Jangan Pakai MTP

MTP nggak selalu menguntungkan. Ada skenario di mana speculative decoding justru bisa kontraproduktif:

• Tugas yang sangat kreatif (creative writing, poetry): Acceptance rate rendah karena variabilitas tinggi → banyak komputasi terbuang

• Reasoning mode high: Model udah menghasilkan chain-of-thought yang panjang; MTP bisa menambah overhead tanpa manfaat signifikan

• VRAM terbatas: MTP layer tetap makan VRAM (~7.6GB untuk layer 3.8B di BF16), jadi kalau Teman-Teman udah mepet, mending matikan MTP

Rule of thumb dari MUGHU: nyalakan MTP untuk deployment produksi yang throughput-oriented (API server, batch processing), matikan untuk eksperimen single-request yang latency-oriented.

Membangun Aplikasi Produksi dengan Hy3: Arsitektur dan Pola Desain

Setelah ngoprek beberapa hari, MUGHU nemu beberapa pola desain yang bekerja baik banget untuk aplikasi produksi pakai Hy3. Ini based on pengalaman nyata — bukan cuma teori.

Pola 1: Router Agent dengan Fallback

Salah satu kekuatan Hy3 adalah kemampuan tool-call-nya yang stabil. Tapi untuk produksi, jangan cuma ngandelin satu model. Pakai pola router:

User Request → Router (Hy3, reasoning=low)
                    ├── Query sederhana → Hy3 (no_think) → Response
                    ├── Coding task → Hy3 (high) + CodeExecutor → Response
                    ├── Research task → Hy3 (low) + SearchTool → Response
                    └── Gagal/sulit → Fallback ke API GPT-4/Claude

Implementasi simpelnya:

from openai import OpenAI
import hashlib

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

def classify_intent(query: str) -> str:
    """Klasifikasi intent pakai Hy3 dengan reasoning rendah."""
    response = client.chat.completions.create(
        model="hy3",
        messages=[{
            "role": "system",
            "content": "Klasifikasikan query user ke salah satu: simple, coding, research."
        }, {
            "role": "user",
            "content": query
        }],
        temperature=0.6,
        max_tokens=20,
        extra_body={"chat_template_kwargs": {"reasoning_effort": "no_think"}},
    )
    result = response.choices[0].message.content.lower()
    if "coding" in result:
        return "coding"
    elif "research" in result:
        return "research"
    return "simple"

def route_query(query: str):
    intent = classify_intent(query)

    if intent == "coding":
        return client.chat.completions.create(
            model="hy3",
            messages=[{"role": "user", "content": query}],
            temperature=0.3,
            extra_body={"chat_template_kwargs": {"reasoning_effort": "high"}},
        )
    elif intent == "research":
        return client.chat.completions.create(
            model="hy3",
            messages=[{"role": "user", "content": query}],
            tools=[search_tool, browse_tool],
            temperature=0.7,
            extra_body={"chat_template_kwargs": {"reasoning_effort": "low"}},
        )
    else:
        return client.chat.completions.create(
            model="hy3",
            messages=[{"role": "user", "content": query}],
            temperature=0.9,
            extra_body={"chat_template_kwargs": {"reasoning_effort": "no_think"}},
        )

Kenapa pola ini penting? Karena nggak semua query perlu reasoning high — boros banget kalau user cuma nanya "jam berapa sekarang" tapi model mikir 10 detik dulu. Sementara itu, coding task yang kompleks memang butuh penalaran dalam. Router memisahkan keduanya secara otomatis.

Pola 2: Caching Response untuk Hemat Biaya

Buat aplikasi yang banyak menerima query mirip (misal customer support, FAQ bot), caching bisa nurunin biaya inference signifikan:

import redis
import hashlib
import json

cache = redis.Redis(host="localhost", port=6379, db=0)

def cached_chat(messages, ttl=3600):
    # Buat cache key dari messages
    cache_key = hashlib.md5(
        json.dumps(messages, sort_keys=True).encode()
    ).hexdigest()

    # Cek cache dulu
    cached = cache.get(cache_key)
    if cached:
        return json.loads(cached)

    # Kalau nggak ada, panggil model
    response = client.chat.completions.create(
        model="hy3",
        messages=messages,
        temperature=0.9,
        extra_body={"chat_template_kwargs": {"reasoning_effort": "no_think"}},
    )

    result = response.choices[0].message.content
    cache.setex(cache_key, ttl, json.dumps(result))
    return result

Dengan Redis sebagai cache layer, Teman-Teman bisa hemat 50-70% biaya inference untuk workload yang repetitif. Ini kerja bagus terutama kalau pakai API OpenRouter setelah masa gratis habis — setiap cache hit artinya ¥1.2 yang nggak perlu keluar.

Pola 3: Streaming Response untuk UX Lebih Baik

Hy3 support streaming via OpenAI-compatible API. Ini krusial buat aplikasi chat karena user nggak suka nunggu:

def stream_chat(messages):
    stream = client.chat.completions.create(
        model="hy3",
        messages=messages,
        temperature=0.9,
        stream=True,
        extra_body={"chat_template_kwargs": {"reasoning_effort": "no_think"}},
    )

    for chunk in stream:
        if chunk.choices[0].delta.content:
            yield chunk.choices[0].delta.content

Untuk SPA frontend (React, Vue), tinggal consume response ini dengan EventSource atau fetch dengan ReadableStream. Hasilnya: user liat teks muncul bertahap, bukan loading spinner doang.

Hy3 untuk Developer Indonesia: Peluang dan Use Case Nyata

Nah, ini bagian yang MUGHU rasa paling relevan buat Teman-Teman di Indonesia. Gimana caranya model sekuat Hy3 bisa dipakai untuk kasus nyata di ekosistem tech lokal?

Use Case 1: Chatbot Layanan Pelanggan Bahasa Indonesia

Banyak perusahaan di Indonesia — dari e-commerce, fintech, sampai telekomunikasi — butuh chatbot CS yang ngerti nuansa bahasa Indonesia. Bahasa Indonesia itu tricky buat model Barat karena:

• Campur kode (code-mixing) Indonesia-Inggris yang lazim di percakapan sehari-hari

• Ragam bahasa formal dan informal yang jauh berbeda

• Konteks lokal yang spesifik (layanan, regulasi, kebiasaan)

Hy3 dengan vocabulary 120.832 token dan skor MMMLU 80.15 punya fondasi yang solid. Untuk deployment:

Arsitektur Chatbot CS:
User → FastAPI + Hy3 Router → Hy3-8GPU → Response
                                ↓ (kalau nggak yakin)
                           Fallback ke Human Agent

Dengan RAG (Retrieval-Augmented Generation) nambahin knowledge base produk, akurasi bisa makin tinggi. Karena self-hosted, data pelanggan nggak perlu keluar dari infrastruktur perusahaan — ini value proposition besar di industri yang regulasinya ketat kayak perbankan.

Use Case 2: Coding Assistant Alternatif GitHub Copilot

Buat tim engineering di Indonesia, biaya langganan GitHub Copilot ($10-19/bulan/orang) bisa jadi beban — apalagi buat startup kecil dengan 20+ developer. Dengan Hy3 self-hosted:

• Biaya per developer: ~$0 (setelah investasi infrastruktur awal)

• Integrasi: Bisa pakai Continue.dev atau plugin VS Code yang support OpenAI-compatible API

• Kustomisasi: Bisa di-fine-tune dengan codebase internal perusahaan

Setup simpel untuk Continue.dev:

{
  "models": [{
    "title": "Hy3",
    "provider": "openai",
    "model": "hy3",
    "apiBase": "http://your-hy3-server:8000/v1",
    "apiKey": "EMPTY"
  }]
}

Untuk hasil terbaik di coding, pakai mode reasoning_effort: "high" dengan temperature rendah (0.3). MUGHU udah coba untuk nulis Python, JavaScript, dan sedikit Rust — hasilnya solid, terutama untuk task yang sifatnya jelas seperti implementasi algoritma, refactoring, dan nulis unit test.

Use Case 3: Document Processing Pipeline

Konteks 256K Hy3 bikin model ini ideal untuk pemrosesan dokumen panjang. Bayangin pipeline kayak gini:

Dokumen Legal/PDF → OCR/Ekstraksi → Hy3 (256K context) → Ringkasan, Analisis, Ekstraksi Klausul → Dashboard

Untuk law firm atau legal tech startup, kemampuan baca kontrak 100+ halaman dan nge-spot klausul bermasalah itu game-changer. Nggak perlu lagi lawyer junior baca dokumen berjam-jam — Hy3 bisa kasih first-pass analysis dalam hitungan menit.

Kuantisasi FP8 dan Efisiensi Deployment

Selain varian BF16 standar, Tencent juga merilis Hy3-FP8 — versi terkuantisasi yang diproses lewat pipeline AngelSlim. Buat Teman-Teman yang infrastrukturnya terbatas, ini bisa jadi alternatif menarik.

Bedanya BF16 dan FP8

Perlu dicatat: FP8 bukan berarti "setengah kualitas." Dalam banyak benchmark, penurunannya minimal — seringkali kurang dari 1-2% untuk task umum. Tapi untuk task yang sensitif terhadap presisi (misal kalkulasi matematika presisi tinggi atau kode numerik), BF16 masih jadi pilihan lebih aman.

Kapan FP8 Jadi Pilihan Tepat

• Eksperimen dan prototyping: Kalau masih tahap uji coba, nggak perlu invest 8 GPU mahal. 4 GPU dengan FP8 udah cukup.

• Throughput tinggi: Aplikasi yang prioritasnya throughput (banyak request paralel) dapat manfaat dari model lebih kecil yang muat di GPU lebih banyak.

• Budget ketat: Startup yang baru mulai dan belum bisa justify investasi 8 GPU H20.

Kalau Teman-Teman penasaran soal pipeline kuantisasi, Tencent punya dokumentasi lengkap di repositori AngelSlim. Prosesnya cukup straightforward: download model BF16, jalanin pipeline kuantisasi, dan deploy hasilnya dengan flag yang sama seperti deployment biasa.

Hybrid Deployment: Mix Self-Hosted + API

Satu strategi yang MUGHU temukan efektif: hybrid deployment. Intinya, pakai self-hosted Hy3 untuk workload baseline, dan fallback ke API (OpenRouter) untuk peak load atau task spesifik.

Kenapa Hybrid?

Self-hosting kasih kontrol penuh dan biaya marjinal rendah — tapi kapasitasnya terbatas sama jumlah GPU yang Teman-Teman punya. Kalau tiba-tiba ada traffic spike (misal produk lagi promo, user naik 10×), server self-hosted bisa kewalahan. Di sisi lain, API selalu available tapi lebih mahal per token.

Hybrid approach kasih best of both worlds:

import random

def hybrid_chat(messages):
    # 80% request ke server lokal, 20% ke OpenRouter (atau dinamis)
    if random.random() < 0.8:
        try:
            return local_client.chat.completions.create(
                model="hy3",
                messages=messages,
                timeout=10,  # Timeout rendah — kalau sibuk, langsung fallback
            )
        except Exception:
            pass  # Fallback ke API

    return openrouter_client.chat.completions.create(
        model="tencent/hy3",
        messages=messages,
    )

Ini bisa diperhalus dengan load balancer yang monitor utilisasi GPU lokal. Kalau GPU utilization udah di atas 90%, otomatis routing ke OpenRouter. Kalau di bawah 60%, semua request ke lokal.

Kalkulasi Biaya Hybrid

Misal Teman-Teman punya 1 server dengan 8× H20, mampu ngelayani ~500 request per menit. Kebutuhan real: 400-800 RPM (rata-rata 600). Dengan hybrid:

• 600 RPM lokal: Biaya listrik + maintenance server (fixed cost, estimasi ~$50/hari untuk listrik di Indonesia)

• 200 RPM API: ¥1.2 per 1M token input. Anggap rata-rata 500 token per request → 200 × 500 × 60 × 24 = 144M token/hari → ¥172/hari (~$24/hari)

Total: $74/hari untuk 800 RPM. Bandingkan dengan full API: ¥691/hari ($97/hari). Hemat ~24%.

Tapi kalkulasi ini sangat tergantung volume dan pola penggunaan. Makin tinggi utilisasi server lokal, makin hemat hybrid-nya.

Keamanan dan Data Privacy dengan Hy3 Self-Hosted

Ini topik yang sering diabaikan developer pas excited ngoprek model baru. Karena Hy3 bisa di-self-host, Teman-Teman punya kendali penuh atas data — tapi kendali penuh juga artinya tanggung jawab penuh.

Yang Perlu Diperhatikan

1. Model weights bukan "trusted code"

Model AI itu ibarat binary executable raksasa — dia bisa mengandung backdoor atau perilaku tak terduga. Meskipun Tencent adalah perusahaan reputable dan Hy3 open-source, tetap terapkan prinsip sandboxing:

# Jalankan inference server di container terisolasi
docker run --gpus all \
  --network isolated-net \
  --read-only \
  --tmpfs /tmp \
  vllm-hy3:latest

2. Jangan expose server inference ke publik

OpenAI-compatible API bawaan vLLM dan SGLang nggak punya autentikasi. Siapa pun yang bisa akses endpoint bisa pakai model Teman-Teman. Solusi simpel:

# Reverse proxy dengan autentikasi
# Pakai nginx + API key

Atau kalau butuh solusi lebih robust, pakai Kong, Traefik, atau API gateway lain yang support rate limiting dan autentikasi.

3. Input sanitization

Meskipun Hy3 didesain untuk menolak prompt berbahaya, tetap validasi input dari user:

def sanitize_input(text: str) -> str:
    # Batasi panjang input (jangan biarin user kirim 256K token mentah-mentah)
    if len(text) > 100_000:
        raise ValueError("Input terlalu panjang")
    # Filter karakter kontrol
    return "".join(ch for ch in text if ch.isprintable() or ch in "\n\t")

4. Logging dan audit trail

Untuk compliance (apalagi kalau handle data customer), semua interaksi dengan model harus dilog:

import logging
import datetime

def log_interaction(user_id, messages, response):
    logging.info(json.dumps({
        "timestamp": datetime.datetime.now().isoformat(),
        "user_id": user_id,
        "input_hash": hashlib.sha256(str(messages).encode()).hexdigest(),
        "response_length": len(response),
        "model": "hy3",
    }))

Data log ini penting buat debugging, audit kepatuhan, dan analisis penggunaan.

Ekosistem dan Tools Pendukung

Meskipun Hy3 masih relatif baru, ekosistem di sekitarnya berkembang cukup cepat. Beberapa tools yang udah kompatibel:

Framework Agent

IDE Integration

• Continue.dev: Support penuh via OpenAI-compatible provider

• Cline (VS Code): Salah satu scaffolding agent yang di-test Tencent — varians akurasi ≤4%

• Aider: AI pair programming di terminal, cukup ganti OPENAI_API_BASE

Observability

• Langfuse: LLM tracing dan analytics — support OpenAI-compatible endpoints

• Phoenix (Arize): Observability untuk debugging model

• Weights & Biases: Tracking eksperimen, bisa diintegrasikan dengan inference server

Buat Teman-Teman yang serius mau bangun aplikasi produksi, MUGHU saranin mulai dari Langfuse untuk observability — setup-nya paling straightforward dan gratis untuk skala kecil.

Refleksi dari Beberapa Hari Ngoprek Hy3

Setelah hampir seminggu penuh main-main sama Hy3 — dari deployment, fine-tuning kecil-kecilan, sampai bikin prototype agent — ada beberapa kesan yang MUGHU rasa perlu dibagikan.

Pertama, ini model yang jujur. Maksudnya, dia nggak overpromise. Kalau nggak tahu jawaban, dia bilang nggak tahu — bukan asal mengada-ada. Filosofi "jawab kalau ada dasarnya" dari tim Hy itu kerasa di penggunaan sehari-hari. Halusinasi tetap ada (5.4% itu bukan nol), tapi jauh lebih jarang dibanding model sekelas yang pernah MUGHU coba.

Kedua, stabilitas tool-call-nya bikin pengembangan agent jadi jauh lebih mulus. Agent loop yang dulunya sering "nyangkut" karena model salah format tool call atau lupa harus manggil tool apa — sekarang hampir selalu mulus. Ini bukan improvement kecil; di production, setiap error tool call artinya request gagal, user kecewa, dan engineering time kebuang buat debugging.

Ketiga, konteks 256K itu bukan gimmick. MUGHU pernah kasih dokumen teknis ~180 halaman dan nanya pertanyaan spesifik tentang bagian tertentu — Hy3 bisa jawab dengan akurat. Nggak semua model dengan klaim "long context" bisa melakukan ini dengan konsisten; banyak yang mulai "linglung" di atas 32K token.

Keempat, biarpun keren, self-hosting Hy3 bukan buat semua orang. Investasi 8 GPU H20 itu serius — untuk konteks Indonesia, itu setara ratusan juta rupiah. Tapi dengan masa gratis 2 minggu dan opsi API yang harganya kompetitif, Teman-Teman bisa evaluasi dulu sebelum commit. Mulai dari API dulu, ukur value-nya, baru pertimbangkan self-hosting kalau volumenya udah justify investasi.

Benchmark Tambahan yang Jarang Dibahas

Di luar benchmark mainstream kayak MMLU dan MATH, ada beberapa metrik menarik dari laporan resmi yang MUGHU rasa relevan:

Konsistensi Multi-Turn

Ini adalah salah satu area di mana Hy3 Final menunjukkan improvement paling signifikan. Dalam pengujian internal Tencent, tingkat issue di percakapan panjang (10+ turn) turun dari 17.4% ke 7.9%. Artinya, model jauh lebih bisa diandalkan untuk aplikasi chat yang sesungguhnya — bukan cuma single-turn Q&A.

Kemampuan Frontend

Dari blind evaluation dengan 270 expert, keunggulan Hy3 paling terasa di frontend development. Model bisa menghasilkan kode HTML/CSS/React yang rapi dan fungsional. Ini konsisten dengan skor LiveCodeBench-v6 34.86 yang jadi yang tertinggi di kelasnya.

Buat developer yang banyak bergulat dengan UI, ini kabar bagus. Bayangin: kasih deskripsi komponen → Hy3 generate kode React lengkap dengan styling. Nggak selalu sempurna, tapi cukup jadi starting point yang solid.

Data & Storage Tasks

Area lain di mana Hy3 unggul adalah query database dan manipulasi data. Blind evaluation menunjukkan akurasi lebih tinggi dibanding GLM-5.1 untuk task seperti nulis SQL query kompleks, migrasi data, dan optimasi skema. Buat data engineer, ini nilai tambah yang signifikan.

Rencana Jangka Panjang: Apa yang Bisa Kita Harapkan?

Meskipun Hy3 baru saja rilis, roadmap ke depannya sudah mulai kelihatan. Berdasarkan pengumuman resmi dan komunikasi tim Hy:

Scaling berkelanjutan. Tim Hy masih aktif meningkatkan skala pre-training dan RL. Ini artinya Hy3 bukan model "sekali rilis lalu ditinggal" — bakal ada iterasi dan improvement berkala.

Ekspansi kemampuan agent. Target berikutnya adalah task agentic yang lebih kompleks, termasuk benchmark OpenClaw yang lebih menantang. Buat developer agent, ini sinyal bahwa investasi belajar ekosistem Hy3 sekarang akan terbayar di masa depan.

Integrasi produk yang makin dalam. Dengan hampir 50 unit bisnis Tencent yang udah antre untuk integrasi, feedback loop ke tim development bakal tetap kuat. Setiap bug yang ditemukan user Yuanbao atau CodeBuddy adalah kandidat perbaikan untuk versi berikutnya.

Potensi varian yang lebih kecil. Meskipun belum diumumkan resmi, komunitas berspekulasi bahwa arsitektur MoE Hy3 bisa di-scale down untuk varian yang lebih terjangkau — mungkin 50B total dengan 8B aktif. Ini akan membuka pintu untuk deployment di hardware yang lebih modest.

Memulai dengan Hy3 Hari Ini: Checklist Ringkas

Biar Teman-Teman nggak bingung harus mulai dari mana, ini checklist praktis yang MUGHU susun:

1. Coba gratis dulu. Akses lewat Nous Portal atau OpenRouter — nggak perlu setup apa pun, tinggal login dan chat.

2. Uji dengan use case nyata. Jangan cuma ngetes "bikin pantun" atau "terjemahkan teks." Kasih task yang beneran bakal dipakai di production Teman-Teman — coding, analisis dokumen, agent workflow.

3. Evaluasi metrik yang relevan. Akurasi, latency, biaya — ukur untuk workload spesifik, jangan cuma ngandelin benchmark internasional.

4. Kalau cocok, baru investasi hardware. Mulai dari skala kecil: sewa GPU cloud dulu (misal GPU H20 di cloud provider), baru beli hardware sendiri kalau udah jelas volume dan butuhnya.

5. Gabung komunitas. GitHub Discussions Hy3, forum Hugging Face, dan server Discord komunitas AI Indonesia adalah tempat bagus untuk tanya-jawab dan berbagi pengalaman.

Ada satu hal lagi yang MUGHU pelajari dari pengalaman bertahun-tahun ngoprek model open-source: jangan terjebak FOMO. Setiap bulan ada model baru dengan klaim "paling canggih." Yang penting bukan selalu pakai yang terbaru, tapi pakai yang paling cocok dengan kebutuhan dan infrastruktur yang Teman-Teman punya. Dan untuk banyak use case — terutama yang butuh keseimbangan antara performa, biaya, dan kontrol — Hy3 adalah kandidat yang sangat solid saat ini.

Hy3 membuktikan bahwa model open-source dari Asia nggak cuma bisa bersaing, tapi juga memimpin di beberapa area krusial seperti penalaran matematika dan stabilitas agent. Akses gratis selama dua minggu adalah undangan terbuka buat developer Indonesia untuk eksplorasi tanpa risiko. Manfaatkan kesempatan ini sebaik mungkin — karena di dunia AI yang bergerak secepat ini, momentum adalah segalanya.

Kesimpulan

Setelah membedah seluruh aspek Hy3 — dari arsitektur MoE-nya yang efisien, performa benchmark yang kompetitif, hingga stabilitas agent yang jadi nilai jual utama — satu hal semakin jelas: ini bukan sekadar model open-source biasa yang ikut ramai-ramai di arena LLM. Hy3 hadir dengan proposisi yang tertarget. Ia tidak mencoba jadi yang terbaik di segala hal, melainkan unggul di area yang benar-benar penting buat production: penalaran matematika, coding, dan task agentic yang membutuhkan konsistensi tinggi. Pendekatan "deep rather than broad" ini justru membuatnya lebih menarik dibanding model yang jago semua benchmark tapi nggak bisa diandalkan di dunia nyata.

Buat developer Indonesia yang selama ini mengandalkan model-model Barat, Hy3 membawa angin segar: sebuah alternatif dari Asia dengan lisensi yang ramah, performa yang teruji, dan ekosistem yang didukung langsung oleh raksasa teknologi seperti Tencent. Fakta bahwa hampir 50 unit bisnis internal Tencent sudah mengadopsi Hy3 adalah sinyal production-readiness yang jauh lebih meyakinkan daripada sekadar skor benchmark. Kalau internal Tencent saja percaya untuk produk-produk seperti Yuanbao dan CodeBuddy, developer eksternal punya alasan kuat untuk ikut serius mengevaluasinya.

Tentu saja, tidak ada model yang sempurna. Hy3 belum tentu cocok untuk semua workload, dan MUGHU selalu menekankan satu prinsip yang sudah teruji di lapangan: pilih model berdasarkan kebutuhan nyata, bukan hype. Namun setelah eksplorasi mendalam di artikel ini, kami cukup yakin bahwa Hy3 layak masuk shortlist siapa pun yang mencari keseimbangan antara performa, biaya inferensi, dan kebebasan deployment. Kombinasi performa penalaran yang tajam dengan arsitektur MoE yang hemat komputasi adalah sweet spot yang jarang ditemukan di pasar open-source saat ini.

Akhir kata, periode uji coba gratis yang masih berlangsung adalah jendela yang tidak boleh disia-siakan. Seperti yang sering kami tekankan dalam panduan evaluasi model AI, tidak ada benchmark yang bisa menggantikan pengujian langsung dengan data dan workload milik sendiri. Buka Nous Portal atau OpenRouter sekarang, jalankan task production Teman-Teman, dan biarkan hasilnya berbicara. Di era di mana model baru bermunculan setiap minggu, yang membedakan developer yang maju dan yang tertinggal bukanlah siapa yang paling cepat mencoba, melainkan siapa yang paling cermat mengevaluasi dan paling berani mengambil keputusan. Hy3 sudah di depan mata — sekarang giliran Teman-Teman yang menentukan apakah model ini layak jadi bagian dari stack production.

Referensi

GitHub. (2026). Hy3: A 295B Mixture-of-Experts model with 21B active parameters for reasoning and agentic tasks.

GitHub. (2026). Hy3 Preview: A 295B Mixture-of-Experts model, the first trained on Tencent's rebuilt infrastructure.

Hy3AI. (2026). Hy3 Preview — Tencent Hunyuan 3 open-source model overview.

Hugging Face. (2026). Tencent Hy3: A 295B Mixture-of-Experts model for reasoning, agentic workflows, and production use.

Mervin Praison. (2026). Tencent Hy3: 295B MoE agent model available free on Nous Portal.

LM Market Cap. (2026). Tencent Hy3 pricing and benchmarks 2026.

Hugging Face. (2026). Tencent Hy3 Preview: A 295B Mixture-of-Experts model with 21B active parameters.

Caixin Global. (2026). Tencent launches final Hunyuan 3 model with free AI-agent feature.

ExplainX. (2026). Tencent Hy3: 295B open-source MoE model for agentic coding.

ZGLG. (2026). Tencent officially releases Hunyuan Hy3 with open-source access and nearly 50 internal business units queuing for integration.