TL;DR: Tencent released Hy4 preview on August 28, 2026 — a 770B/49B-active MoE under clean Apache 2.0, with a 1M-token context and an official ~214GiB mixed 1.3-bit GGUF from its own quantization team. That’s the smallest 770B-class footprint anyone has shipped, but it still needs a 256GB machine and a patched llama.cpp. No consumer GPU is anywhere close.

	Hy4 MIX-STQ1_0 local	Hy4 via OpenRouter	Hy3 on a 128GB box
Best for	256GB+ RAM builds, Apache-clean frontier weights	Everyone else, today	Frontier-class MoE you can actually own for ~$2,000
Memory floor	~214GiB + KV cache	$0	91.8GB (official IQ1_M)
Price / Cost	~$4,000+ in RAM/GPUs, or you already own it	$0.834/M in, $2.501/M out	GMKtec EVO-X2 128GB ~$1,999–$2,199
The catch	Patched llama.cpp only; single-digit tok/s realistic	Prompts leave your machine	A generation behind Hy4 on engineering tasks

Honest take: Hy4 preview is the best-behaved frontier drop of the year — Apache 2.0, FP8 and a ~200GiB official quant on day one — and you still shouldn’t try to run it at home unless you already own a 256GB machine. Use the API at $2.50/M output, keep Hy3 on the 128GB box, and watch for the hyv4 llama.cpp merge before spending a dollar on hardware.

August 28 was a strange day for open weights: GLM-5.3’s full weights landed under a new custom license, and a few hours apart Tencent open-sourced its new flagship under plain Apache 2.0. Five weeks earlier, Kimi K3’s 1.56TB drop had already stretched the definition of “open weights you can use.” So the question that matters for this site isn’t whether Hy4 preview is impressive — it’s whether Tencent repeated the trick that made Hy3 the first 295B model to fit a $2,000 home-lab box, or whether 770B parameters put the flagship back behind the datacenter wall.

Short version: they tried — harder than any other lab — and physics still won. Here’s the real memory map.

What Tencent shipped on August 28

Hy4 preview is a 770B-total, 49B-active mixture-of-experts model with a 1M-token context window, released under Apache 2.0 with no geographic or field-of-use restrictions — same clean license Hy3 graduated to in July, and notably cleaner than the custom licenses on GLM-5.3 and Kimi K3. Weights went up on Hugging Face, ModelScope, and Tencent’s own mirrors, alongside an FP8 variant and a fine-tuning pipeline on GitHub.

The architecture, from the model card: 78 layers — one dense FFN layer, then 77 MoE layers with 256 routed experts plus 1 shared expert each, top-8 routing per token. Attention is Gated DeepSeek Sparse Attention (Gated DSA) with an IndexCache that reuses sparse indices across layers — that’s how a 770B model serves a 1M context without the KV cache eating the building. Tencent also claims Hy4 is the first Hunyuan model that helped optimize its own training stack, reporting a 31.8% throughput gain on its inference infrastructure (TechNode).

The benchmark story Tencent leads with is a blind evaluation, not a leaderboard: 163 internal experts scored 203 real engineering tasks, and Hy4 preview averaged 2.99/4.00 against GLM-5.3’s 2.92 (46.8% wins, 12.8% ties) and against Kimi K3’s 2.94 (51.2% wins, 7.9% ties). Treat that with the usual salt — it’s vendor-run, vendor-scored, and the margins are thin. What it credibly establishes is membership in the same tier as the two models it was scored against, not superiority. No independent SWE-bench or Terminal-Bench reproduction existed as of August 31; we said the same about Kimi K2.7’s vendor-only numbers and that caution aged well.

The memory ladder: four sizes, one honest floor

Everything below is verified from the official repos and Tencent’s own posts:

Build	Size	What holds it	Verdict for home labs
BF16 (full)	~1.5TB	16× H200-class	Not your problem
FP8 (official)	~760GB weights	One 8-GPU node (141GB-class cards)	Rent it
Q4_K_M GGUF (official)	~435GiB resident	512GB EPYC builds, 5× RTX PRO 6000	Server territory
MIX-STQ1_0 GGUF (official)	~214GiB resident	256GB DDR5 builds, 2× RTX PRO 6000 + offload	The only realistic local path

Two of these deserve a closer look.

The FP8 node math is sneakier than it looks. ~760GB of weights means eight 80GB H100s (640GB total) don’t fit — the official serving recipes (vLLM and SGLang) assume 141GB-class silicon: H200, H20, or B200. Both paths are prebuilt Docker images with 8-way tensor parallelism baked in:

# Official SGLang image, 8-GPU node
docker run --gpus all --shm-size 32g -p 30000:30000 \
  lmsysorg/sglang:hy4-preview \
  python3 -m sglang.launch_server \
  --model-path tencent/Hy4-preview-FP8 --tp-size 8

# → serves an OpenAI-compatible endpoint on :30000
# (vLLM equivalent: vllm/vllm-openai:hy4-preview with --tensor-parallel-size 8)

That 141GB-per-card requirement costs real money if you’re renting, which we’ll get to.

The MIX-STQ1_0 build is the genuinely new thing. Tencent’s AngelSlim team compressed the 1.5TB checkpoint to roughly 200GiB on disk — ~214GiB resident — using calibration data to pick a bit-width per layer: routed-expert projections run at 1.31 bits (STQ1_0) on 29 layers and 2.06 bits (IQ2_XXS) on the other 48, per Tencent’s own announcement. Same budget, spent where the calibration says quality survives. For comparison, GLM-5.3’s smallest usable quant is 239GB at 2-bit for a 744B model — Hy4 lands ~25GB smaller with ~26B more total parameters. That’s the most aggressive official quantization any frontier lab has shipped, and it continues the pattern that made Hy3 special: Tencent does the compression work itself instead of waiting for Unsloth.

And it’s still not enough for a 128GB box. This is the part worth being blunt about, because the Hy3 story primed everyone to hope: Hy3 at 295B had a 91.8GB official 1-bit build, and a $1,999 GMKtec EVO-X2 ran it at a measured 24.3 tok/s. At 770B, even 1.31-bit mixed precision lands at 214GiB — there is no bit-width left to cut. The floor for this model class is a 256GB machine, full stop. Hy3 fit 128GB because Tencent sized the model for the quant; Hy4 is sized for the blind-eval win instead.

What “49B active” does and doesn’t buy you

The questions we got on Hy3 apply double here, so the recurring myth goes first: 49B active parameters does not mean 49GB of memory. Every one of the 770B parameters must sit in RAM or VRAM, because the router picks a different 8-of-256 expert set every token — you can’t know in advance which ~6% of the weights you’ll need. Active parameters set your speed, not your capacity requirement. (Our VRAM calculator handles MoE models correctly if you want to check a specific quant and context.)

What 49B active does buy is decode speed that scales like a mid-size model once the weights are resident. Per token, the model reads roughly the active fraction of the file: on the ~214GiB STQ1_0 build that’s about 49/770 × 214GiB ≈ ~14GiB of weight traffic per token (our arithmetic, not a benchmark). Run that against real memory bandwidth and you get the honest speed forecast:

• 256GB dual-channel DDR5 desktop (~90 GB/s): ~6 tok/s theoretical ceiling, so expect 2–4 tok/s real. Usable for batch jobs, painful for chat.
• 12-channel DDR5 EPYC / Threadripper PRO (~400–460 GB/s effective): ~30 tok/s ceiling, expect low teens. This matches what 256GB builds measured on GLM-5.2/5.3’s 2-bit quants (3–9 tok/s with less bandwidth), so the arithmetic is in the right neighborhood.
• 2× RTX PRO 6000 96GB (192GB VRAM) + RAM offload for the last ~22GiB: the offloaded expert layers throttle you to PCIe speeds a few times per token; expect it to feel closer to the CPU build than to a resident-in-VRAM model.

No published third-party tok/s runs existed as of August 31 — the model is three days old — so treat every number above as bandwidth math, not measurement. We’ll update when the r/LocalLLaMA crowd does what it always does.

One more practical wall: the GGUF doesn’t load in stock llama.cpp. The hyv4 architecture is not upstream — the official GGUF repo ships a patch directory (0001-hyv4-architecture.patch) you apply to a llama.cpp checkout yourself. The precedent is encouraging: Hy3’s hy_v3 architecture merged into mainline eight days after its GGUF drop. But today, running Hy4 locally means compiling a patched fork, and Ollama support doesn’t exist even as a timeline. Also mind the repo’s own warning: llama.cpp mmaps weights, and paging 200GiB over NFS runs at ~12 MB/s — keep the file on local NVMe or your one-minute load becomes hours.

Renting the real thing: the 8-GPU math

If you want full-quality FP8 Hy4 under your own control — for fine-tuning experiments, batch inference, or just because the Apache 2.0 license lets you do literally anything with it — the sane route is renting the node, not building it. RunPod lists H200 SXM at $4.31/hr per GPU in Instant Clusters as of August 2026, so the 8× H200 node the official recipes assume runs about $34.50/hour, or roughly $25,000/month if you leave it up 24/7.

Against OpenRouter’s Hy4 pricing — $0.834/M input, $2.501/M output, $0.042/M cached input — that node only pays for itself north of ~13 million output tokens per hour, sustained. No individual workload looks like that. Rent by the hour for a weekend of fine-tuning on the official pipeline; use the API for everything else. The rent-vs-buy math we laid out last year hasn’t just held for this model class — it’s gotten more lopsided, because API prices keep falling faster than hardware.

For coding-agent use specifically (Hy4’s blind eval was engineering tasks, and early API access shows ~36 tok/s P50 on OpenRouter), the practical setup today is API-backed: point Cline or Continue at the OpenRouter route — our sister site has the Cline setup walkthrough. Once weights are runnable in mainline llama.cpp, the Open WebUI + Ollama integration path becomes the self-hosted option.

So what should a home lab actually do?

If you own a 128GB unified-memory box (EVO-X2, DGX Spark, 128GB Mac): nothing changes. Hy3’s 91.8GB build remains the biggest frontier-class model your machine can hold, and Hy4 doesn’t obsolete it locally — it can’t fit. The 2.99-vs-2.94 blind-eval margin over Kimi K3 is not a reason to abandon a working local stack.

If you own a 256GB machine: you’re the entire target market for MIX-STQ1_0. Wait for the hyv4 mainline merge (watch llama.cpp — the Hy3 precedent says days-to-weeks, not months) unless you enjoy maintaining patched builds, and budget for single-digit tok/s on desktop bandwidth.

If you’re deciding what to buy: don’t buy anything for Hy4. A used RTX 3090 at ~$1,264 still cannot hold 3% of this model, and no consumer card changes that — the 96GB tier is where single-card ambitions top out, at a fifth of Hy4’s smallest quant. The frontier-MoE class starts at 256GB of fast memory and climbs from there; our GPU buying guide covers what actually makes sense per budget. The models getting better per gigabyte — the MoE efficiency story — are the 26B–35B class you can already run, not the 770B class you can’t.

The pattern across August 2026’s three frontier drops is now unmistakable: GLM-5.3 at 239GB minimum, Kimi K3 at 1.56TB, Hy4 at 214GiB. The open-weight frontier is real, the licenses are workable, and the hardware floor sits stubbornly at 4–10× what a consumer machine holds. Tencent came closest to bending that — an official 1.3-bit quant is something nobody else even attempts — and the gap is still a full memory class wide.

FAQ

Can an RTX 4090 or RTX 5090 run Hy4 preview? No. The smallest official build needs ~214GiB resident; a 5090 has 32GB. Even with aggressive RAM offload, a single consumer card holds under 15% of the smallest quant, and decode speed collapses to well under 1 tok/s territory. This model class is out of consumer-GPU reach at any quantization.

Doesn’t 49B active parameters mean I only need ~49GB? No — that’s the most common MoE misreading. All 770B parameters must be in memory because each token routes to a different expert subset. Active parameters determine tokens/second, not the memory floor.

Is Hy4 worth running locally instead of Hy3? Only if you already own a 256GB machine. On 128GB hardware, Hy3 remains the ceiling and it’s genuinely good. The blind-eval gap between Hy4 and the GLM-5.3/Kimi K3 tier is a few percent on vendor-scored tasks — not worth $2,000+ of RAM by itself.

Is the Apache 2.0 license actually unrestricted? Yes, per the model card: standard Apache 2.0, no geographic limits, no user-count clause, no field-of-use carve-outs. Among August’s frontier drops, that makes Hy4 the cleanest — GLM-5.3 shipped a custom license and Kimi K3’s carries attribution thresholds.

When will Ollama or stock llama.cpp support Hy4? No timeline exists as of August 31, 2026. The official GGUF requires patching llama.cpp with the provided hyv4 patch. Hy3’s architecture merged upstream 8 days after its GGUF release, so a mainline merge within weeks is plausible — Ollama support typically follows the mainline merge by days.

Recommended Gear

• GMKtec EVO-X2 128GB — still the cheapest box that runs a frontier-class MoE (Hy3, not Hy4)
• Used RTX 3090 24GB — the value pick for the models you can actually run

Sources

• Tencent Releases and Open-Sources Tencent Hy4 preview — Tencent
• tencent/Hy4-preview model card — Hugging Face
• tencent/Hy4-preview-FP8 — Hugging Face
• Tencent-Hunyuan/Hy4-preview (fine-tuning pipeline and recipes) — GitHub
• AngelSlim/Hy4-preview-GGUF (official Q4_K_M and MIX-STQ1_0 builds) — Hugging Face
• MIX-STQ1_0 compression announcement — Tencent Hy on X
• Tencent open-sources Hy4 preview with 770B parameters and a 1M-token context — TechNode
• Introducing Hy4 Preview — Simon Willison
• Hy4 preview blind-eval breakdown vs GLM-5.3, Kimi K3 — Data Science in Your Pocket (Medium)
• Hy4 preview — API pricing and providers — OpenRouter
• tencent/Hy4-preview serving recipe — vLLM Recipes
• Hy4 preview deployment — SGLang Documentation
• RunPod GPU pricing breakdown (H200 SXM Instant Clusters) — Northflank

Last updated August 31, 2026. Prices, quant sizes, and API rates change; verify current numbers before purchasing.