Hy4 preview is a new-generation Mixture-of-Experts (MoE) flagship model developed by the Tencent Hy Team. The model comprises 770B total parameters, of which 49B are activated per token. We scaled Hy4 on three fronts: model size, context length, and training data.

HuggingFace ModelScope

🖥️ Official Website

Model Introduction

Hy4 preview’s backbone consists of 78 layers, where the first layer uses a standard dense FFN and the remaining 77 layers replace it with MoE, each containing 256 routed experts and 1 shared expert; every token activates the top-8 routed experts along with the shared expert. In addition to the backbone, 1 native MTP layer (10B total parameters, 0.7B activated) is built in for speculative decoding.

On the architecture side, inspired by DeepSeek and GLM, the attention module employs Gated DeepSeek Sparse Attention (Gated DSA) with IndexCache for cross-layer sparse index reuse. The residual pathway uses iHC (identity Hyper-Connections) to expand inter-layer information flow.

Model Specifications

The table below lists backbone parameters only, excluding the MTP layer.

PropertyValue
ArchitectureMixture-of-Experts (MoE)
Total Parameters770B
Activated Parameters49B
Layers78
Hidden Size6144
Attention TypeGated DSA
Attention Heads64
Query Compression Dimension2048
Key-Value Compression Dimension512
Indexer Heads / Head Dimension32 / 128
Indexer top-k2048
Residual Streams4
Routed Experts256
Shared Experts1
Activated Routed Experts per Token8
MoE Intermediate Size2048
FFN Intermediate Size18432
Context Length1M
Vocabulary Size120832

A New Flagship Generation

Stronger pre-training and a substantially larger post-training run compound into another step change in capability — the largest generation-over-generation gain we’ve measured, and enough to put Hy4 preview at the open-source frontier.

Benchmarks

Built for Productivity

We partnered with top experts inside Tencent — such as software engineers, game developers, finance analysts, and security experts — and built training data around the work they ship. The result is a model that gets meaningfully further on the tasks these teams run every day:

Software engineering: Better at understanding, planning, debugging, and verifying long-horizon development tasks, with further gains in the visual taste and interaction quality of front-end work.

Office and analysis: Takes messy context spread across many files and converts it into shareable artifacts — documents, spreadsheets, and presentations — handling data analysis, equations, and financial models with greater precision.

Game development: Turns a single prompt into a playable prototype and works fluently with game engines, so developers can keep refining complex projects over multiple turns.

Scientific research: Stronger understanding, reasoning, and problem-solving on hard research questions, with solid progress across AI research, molecular dynamics, condensed matter physics, and pure mathematics.

We also continue to co-design Hy4 preview with Tencent products like CodeBuddy and WorkBuddy, so that gains in the model show up in the work people actually do with it. To check that, we ran a blind side-by-side evaluation: 163 internal experts rated model outputs on 203 engineering tasks. Hy4 preview came out slightly ahead of both GLM 5.3 (2.99 vs. 2.92 average, 46.8% wins / 12.8% ties / 40.4% losses) and Kimi K3 (2.99 vs. 2.94, 51.2% wins / 7.9% ties / 40.9% losses).

Benchmarks

BenchmarkHy4 previewDeepSeek V4 Pro 0813Qwen 3.8 MaxGLM 5.3Kimi K3GPT 5.6 SolClaude Opus 5
Agentic Coding
SWE-bench Multilingual82.977.3*82.6*81.3*80.8*74.1*89.5/85.8*
SWE-bench Pro65.760.3*67.7/61.6*64.6*63.3*64.6/60.5*79.2/79.9*
DeepSWE64.362.7/58.8*56.6/55.6*66.9/68.1*67.5/74.0*72.7/68.9*68.8/74.7*
SWE Atlas - Codebase Q&A64.053.4*55.4*55.8*35.2*58.1*57.5*
SWE Atlas - Test Writing57.845.6*52.8*49.6*35.6*49.6*68.7*
SWE Atlas - Refactoring53.348.6*51.0*51.9*37.4*52.4*60.0*
SWE-Marathon31.919.0*31.0*42.5/35.6*42/44.4*42.5/35.9*50.0/48.0*
Terminal-Bench 2.185.487.9/80.3*86.6/85.8*88.2/88.3*88.3/85.7*88.8/88.3*86.7/85.4*
NL2Repo-Bench58.961.5/54.4*55.9/58.0*58.0/56.1*58.0/58.3*56.8*75.3*
CyberGym78.483.3/80.3*78.5/78.5*84.5/83.0*80.083.6-
ProgramBench17.515.5*17.5*18.0*24.5*25.0*39.5*
PostTrainBench V1.135.624.5*-33.2*32.0*36.235.0
Harbor-Index39.636.9*38.8*42.5*-46.3*56.9*
Hy-Backend 2.0 (Internal)35.233.8*34.9*41.9*37.9*49.6*40.3*
Hy-SWE Max Verified (Internal)64.265.7*65.2*67.2*65.6*69.8*70.1*
Hy-CompanyBench V2 (Internal)62.464.4*63.3*64.5*63.3*70.6*72.7*
Agentic Search
WideSearch83.981.8*81.9/81.1*83.2*81.0*86.3*84.0*
OneMillionBench (with tools)65.462.0*63.1*64.5*63.5*67.1*68.1*
DRACO77.277.3*76.4*78.1*77.5*77.7*88.6/79.2*
Hy-LifeSearch (Internal)49.246.9*47.5*49.2*45.8*63.4*56.1*
Hy-BrowseComp-Pro2 (Internal)56.146.5*46.7*48.4*58.1*56.4*61.3*
Working Agent
OfficeQA Pro66.265.4*65.4*66.2*65.4*65.4*66.9/66.9*
MCP-Atlas (public)83.782.5*81.9*81.9*84.2/82.8*82.5*85.7*
Toolathlon-Verified74.174.1/70.1*72.5/69.1*73.0/73.8*76.5/74.7*73.2*76.5*
APEX-Agents (pass@1)37.132.4*34.0*38.1*41.0/37.2*39.9/37.9*41.8*
SkillsBench (79, text-only)62.965.0*66.7*63.3*51.9*62.5*63.7*
JobBench61.754.1*53.0/52.2*58.2*54.3/54.7*45.4/46.8*68.0*
WorkspaceBench60.265.4*67.7/66.9*68.2*65.0*65.3*75.0*
Agents’ Last Exam (ALE-CLI)22.821.9*25.4*23.8*23.2*27.6*25.1*
GDPval-AA V2 (Elo, official)1678158017171763167517111831
AutomationBench (v1.0.6)32.130.4*39.8/41.1*48.2/49.4*46.7/45.5*45.8/39.9*48.7*
BankerToolBench78.673.1*74.7*77.8*73.5*79.0*81.9*
E-Bench (Internal)77.161.3*66.8*71.4*73.8*80.6*77.8*
E-Bench-Code (Internal)79.064.3*67.1*66.5*77.6*83.3*82.7*
Hy-FinAgentBench (Internal)79.778.5*77.2*80.4*78.5*83.0*82.0*
Hy-FinmodelBench v2 (Internal)57.051.3*52.5*57.8*52.4*65.3*66.0*
STEM Agent
BioMysteryBench71.361.6*58.9*69.0*61.3*73.1*72.1*
HLE (with tools, text-only)55.460.0/55.8*56.2/54.1*62.5/54.3*57.0*60.2*60.9*
Reasoning
CritPt (official)16.918.020.019.123.432.329.1
GPQA Diamond92.392.8/91.7*92.6/92.2*91.7/91.4*93.5/92.8*94.1/94.7*93.7/93.3*
HLE (no tools, text-only)43.442.7/40.5*43.6/41.5*42.346.9/46.6*49.5/49.6*54.9/53.2*
SUPERChem66.462.0*61.9*58.5*66.9*73.6*76.7*
ArXivMath66.662.1*67.1*-60.8*79.5*71.5*
HorizonMath (pass@4)8.84.42*5.31*-7.08*10.62*5.3*
MathArena Apex 202574.266.3*72.8*-68.4*90.0*91.4*
BrokenArXiv54.643.1*42.7*-56.3*64.4*77.7*
Footnotes
  • For each model, we evaluate and report results at the highest available reasoning setting, and results with* are from our own testing.
  • For SWE-bench Multilingual and SWE-bench Pro, we use the swe-agent scaffold.
  • For DeepSWE, we use the mini-swe-agent. Each task runs in a sandbox environment with 8 CPU cores and 16 GB of memory.
  • For SWE-Marathon, we follow the official evaluation settings, except that we set the agent timeout to twice the official value. To reduce variance, we evaluate each task repeatedly until we obtain eight valid scores from successful runs.
  • For Terminal Bench 2.1, we evaluate with the Claude Code harness, allowing up to 500 turns and a 12-hour timeout per trial to give the model sufficient time to complete each task. Resources are capped at 16 CPUs and 32 GB RAM.
  • MCP-Atlas scores follow Scale’s April 2026 methodology on the 500-task public set. We retain the 100 tool-call budget per task and update the judge model from Gemini 2.5 Pro to Gemini 3.1 Pro Preview.
  • SkillsBench: All models are evaluated via Claude Code on 79 tasks (self-contained subset, excluding multimodal tasks); results are averaged over 3 runs.
  • For SWE-Atlas, we fix the rubric judge parsing failure and add a network allowlist restriction to prevent hacking behaviors. All models are evaluated via Claude Code with a 256-turn budget.
  • NL2Repo: All models are evaluated via Claude Code with a 1000-turn budget per task. Additional anti-hacking prompt constraints and tool-call monitoring are applied to prevent hacking behaviors.
  • ProgramBench: All models are evaluated via Claude Code with a 2000-turn budget per task. For DeepSeek-V4-Pro-0803, we found that its thinking frequently gets stuck in a repetitive loop, so we use mini-swe-agent instead.
  • Hy-SWE Max Verified (Internal): All models are evaluated on our in-house self-built benchmark (300 tasks) using the Claude Code scaffold with a 200-turn budget. Each task runs in a sandboxed environment with 16 CPU cores and 32 GB of memory, with web access (WebSearch/WebFetch) disabled and image reading blocked (text-only backend); results are averaged over 3 runs and scored pass/fail by hidden verifier tests.
  • Agent Last Exam (CLI): We evaluate ALE-CLI of 105 tasks following the official evaluation protocol using the Claude Code harness. Each task runs up to 12 hours in a sandboxed environment with 8 CPU cores and 32 GB of memory with the data and software declared in its Task Card. Results are scored by the official ALE evaluators.
  • For Apex-Agents, we evaluate with the official ReAct Toolbelt harness using a maximum of 250 steps per trial. Resources are capped at 4 CPUs and 16 GB RAM.
  • Biomystery: All models, with the exception of gpt-5.6-luna and gpt-5.6-sol, were evaluated with Claude Code as the agentic harness under a per-task budget of 2 hours and 250 turns. For gpt-5.6-luna and gpt-5.6-sol, Codex was adopted as the harness, with all other evaluation conditions held constant. All evaluations were conducted on the initial release of the benchmark, comprising 99 tasks. All answers are judged by Kimi-K3.
  • OfficeQA Pro: We use Claude Code as the agent harness for all models except the GPT series, which are evaluated with Codex CLI.
  • Toolathlon-Verified: we use our internal agent scaffold, internally reimplement some of the MCP tools, pin each task to 2 CPU cores and 10 GB of memory, and use a 2-hour timeout instead of 5400 seconds. The 108-task Verified set, official programmatic evaluators, 100-step budget, 3-run Pass@1 protocol, and highest-tier reasoning effort are unchanged.
  • Agentic Search: All models are evaluated using our internal harness.
  • For BankerToolBench, all models are evaluated via the OpenCode scaffold, and we use Gemini 3 flash as the judge model.
  • Among the eight reasoning benchmarks, five Claude Opus 5 results use high-setting runs, while the others use max-setting runs. The high-setting runs have truncation rates of 2.32% on HLE, 15.17% on ArXivMath, 28.76% on HorizonMath, 5.86% on MathArena Apex 2025, and 17.17% on BrokenArXiv.

Known Limitations

This is an early version of Hy4. There is real headroom left in both pre-training and post-training, and we are shipping with known issues — among them, spending longer than necessary reasoning through complex tasks, and a tendency to over-verify its own work. We’ll keep iterating quickly on these. As with Hy3 preview, we would rather ship early and hear what breaks — that’s what made Hy3 substantially better, and it’s how we will get Hy4 right. We will also keep collaborating closely with Tencent’s products and in-house experts to push the boundaries of model intelligence while making it more abundant and affordable.

Model NameDescriptionHugging FaceModelScopeGitCodeCNB
Hy4 previewInstruct model🤗 ModelModelModelModel
Hy4 preview-FP8FP8 quantized instruct model🤗 ModelModelModelModel

Quickstart

Deploy Hy4 preview with vLLM or SGLang first, then call the OpenAI-compatible API:

from openai import OpenAI

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

response = client.chat.completions.create(
    model="hy4-preview",
    messages=[
        {"role": "user", "content": "Hello! Can you briefly introduce yourself?"},
    ],
    temperature=0.9,
    top_p=1.0,
)
print(response.choices[0].message.content)

Recommended parameters: temperature=0.9, top_p=1.0.

Reasoning mode: Defaults to "high" (deep chain-of-thought), which suits complex tasks such as math, coding, and reasoning. For direct responses, pass extra_body={"chat_template_kwargs": {"reasoning_effort": "no_think"}}.

See the Deployment section below for how to start the API server.

Deployment

For production serving, we recommend using vLLM or SGLang. Please refer to the recipes:

vLLM

Use official prebuilt image vllm/vllm-openai:hy4-preview:

docker run --gpus all \
  -p 8000:8000 \
  --ipc=host \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:hy4-preview tencent/Hy4-preview-FP8 \
    --tensor-parallel-size 8 \
    --speculative-config '{"num_speculative_tokens":3,"method":"mtp"}' \
    --attention-backend FLASHMLA_SPARSE \
    --tool-call-parser hy_v4 \
    --reasoning-parser hy_v4 \
    --enable-auto-tool-choice \
    --port 8000 \
    --served-model-name hy4-preview

SGLang

Use the official prebuilt image lmsysorg/sglang:hy4-preview (multi-arch, x86 and Arm):

docker pull lmsysorg/sglang:hy4-preview

docker run --gpus all --ipc=host -p 8000:8000 lmsysorg/sglang:hy4-preview \
  python3 -m sglang.launch_server \
    --model tencent/Hy4-preview-FP8 \
    --tp-size 8 \
    --reasoning-parser auto \
    --tool-call-parser auto \
    --speculative-algorithm NEXTN \
    --speculative-num-steps 3 \
    --speculative-eagle-topk 1 \
    --speculative-num-draft-tokens 4 \
    --port 8000 \
    --served-model-name hy4-preview

Quantization

We provide AngelSlim, a more accessible, comprehensive, and efficient toolkit for large model compression. AngelSlim supports a comprehensive suite of compression tools for large-scale multimodal models, including common quantization algorithms, low-bit quantization, and speculative sampling.

License

Hy4 preview is released under the Apache License 2.0.