Tencent Hy3 : Guide développeur du modèle MoE open source à 295 milliards de paramètres

Tencent a lancé Hy3 le 6 juillet 2026 — un modèle Mixture-of-Experts à 295 milliards de paramètres n'activant que 21 milliards par token, distribué sous licence Apache 2.0, avec un score de 78.0 sur SWE-Bench Verified. Il rejoint la courte liste des modèles open source qui concurrencent sérieusement les frontières closed-source pour les tâches de codage et de raisonnement.

Ce guide couvre l'architecture, les benchmarks et le déploiement pratique avec des exemples TypeScript.

Qu'est-ce que Hy3 ?

Hy3 (Hunyuan 3) est le dernier modèle de raisonnement et d'agent ouvert de Tencent. Les spécifications clés :

• 295 milliards de paramètres totaux, 21 milliards actifs par token via MoE sparse
• 192 experts avec routage top-8 — seulement 8 experts activés par token
• Couche Multi-Token Prediction (MTP) à 3,8 milliards de paramètres pour le décodage spéculatif
• Fenêtre de contexte 256K pour les grandes bases de code et les longs documents
• Précision BF16 avec une variante FP8 pour réduire la mémoire
• Licence Apache 2.0 — commercialement permissive, utilisable globalement

La conception MoE est le levier de coût principal : chaque passe avant active bien moins de paramètres que le total. Vous obtenez une qualité proche d'un modèle dense à 295 milliards tout en payant des coûts d'inférence proches d'un modèle à 21 milliards.

Benchmarks

Hy3 affiche des résultats solides en codage, raisonnement et évaluation d'agents :

Améliorations de fiabilité entre la préversion d'avril et la version de juillet :

• Taux d'hallucination réduit de 12,5% à 5,4%
• Taux d'erreur de suivi d'intention multi-tours réduit de 17,4% à 7,9%

Pour comparaison, GLM-5.2 (environ 744 milliards total / 40 milliards actifs) mène encore sur certains benchmarks de codage, mais l'empreinte matérielle plus petite de Hy3 le rend plus accessible pour les déploiements auto-hébergés.

Auto-hébergement avec vLLM

Hy3 nécessite 8 GPUs (NVIDIA H20-3e, H200 ou AMD MI300X/MI325X avec au moins 141 Go de VRAM chacun). Le déploiement officiel utilise vLLM.

Option 1 : Docker (Démarrage le plus rapide)

docker run --gpus all \
  -p 8000:8000 \
  --ipc=host \
  -e VLLM_FLASHINFER_ALLREDUCE_BACKEND=trtllm \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:hy3 tencent/Hy3 \
    --tensor-parallel-size 8 \
    --tool-call-parser hy_v3 \
    --reasoning-parser hy_v3 \
    --enable-auto-tool-choice \
    --served-model-name hy3

Option 2 : vLLM direct avec MTP (Recommandé)

Le Multi-Token Prediction accélère la génération en prédisant plusieurs tokens par étape :

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 \
  --served-model-name hy3

Déploiement AMD MI300X

Les utilisateurs AMD définissent ces variables d'environnement avant le service :

export VLLM_ROCM_USE_AITER=1
export VLLM_ROCM_USE_AITER_MOE=1
export VLLM_ROCM_USE_AITER_MHA=1
export VLLM_ROCM_USE_AITER_RMSNORM=1
export VLLM_ROCM_USE_AITER_LINEAR=1
 
vllm serve tencent/Hy3 \
  --tensor-parallel-size 8 \
  --tool-call-parser hy_v3 \
  --reasoning-parser hy_v3 \
  --enable-auto-tool-choice \
  --served-model-name hy3 \
  --gpu-memory-utilization 0.90

Intégration TypeScript

Hy3 expose une API compatible OpenAI, donc le SDK TypeScript openai standard fonctionne immédiatement — pointez simplement baseURL vers votre endpoint vLLM.

Installation

npm install openai

Complétion de chat basique

import OpenAI from "openai";
 
const client = new OpenAI({
  baseURL: "http://localhost:8000/v1",
  apiKey: "EMPTY",
});
 
const response = await client.chat.completions.create({
  model: "hy3",
  messages: [
    { role: "system", content: "Tu es un assistant de codage utile." },
    { role: "user", content: "Écris une fonction TypeScript pour parser du JSON de façon sécurisée." },
  ],
  temperature: 0.9,
  top_p: 1.0,
  max_tokens: 4096,
});
 
console.log(response.choices[0].message.content);

Mode raisonnement approfondi

Pour les tâches complexes — preuves mathématiques, décisions architecturales, débogage difficile — activez la chaîne de pensée avec reasoning_effort: "high" :

const thinkingResponse = await client.chat.completions.create({
  model: "hy3",
  messages: [
    {
      role: "user",
      content: "Conçois un rate limiter distribué pour 10 000 req/s avec Redis.",
    },
  ],
  temperature: 0.9,
  top_p: 1.0,
  max_tokens: 8192,
  // @ts-expect-error — Hy3-specific extra body
  extra_body: {
    chat_template_kwargs: {
      reasoning_effort: "high",
      interleaved_thinking: true,
    },
  },
});
 
const message = thinkingResponse.choices[0].message;
// @ts-expect-error — reasoning_content is Hy3-specific
console.log("Raisonnement:", message.reasoning_content);
console.log("Réponse:", message.content);

Les trois modes reasoning_effort :

Définir interleaved_thinking: true permet au modèle de raisonner entre les appels d'outils — utile pour les tâches multi-étapes où le raisonnement intermédiaire améliore chaque invocation.

Appel d'outils

Hy3 supporte le format standard d'appel de fonctions OpenAI :

const tools: OpenAI.ChatCompletionTool[] = [
  {
    type: "function",
    function: {
      name: "run_tests",
      description: "Exécuter la suite de tests et retourner les résultats",
      parameters: {
        type: "object",
        properties: {
          pattern: {
            type: "string",
            description: "Motif glob pour les fichiers de test",
          },
        },
        required: ["pattern"],
      },
    },
  },
];
 
const agentResponse = await client.chat.completions.create({
  model: "hy3",
  messages: [
    { role: "user", content: "Lance tous les tests dans src/ et résume les échecs." },
  ],
  tools,
  tool_choice: "auto",
  // @ts-expect-error — Hy3-specific extra body
  extra_body: {
    chat_template_kwargs: {
      reasoning_effort: "high",
      interleaved_thinking: true,
    },
  },
});

Variante FP8 pour moins de mémoire

Pour les équipes avec des budgets GPU plus serrés, le modèle FP8 (tencent/Hy3-FP8) réduit les besoins en mémoire avec un léger compromis de précision :

vllm serve tencent/Hy3-FP8 \
  --tensor-parallel-size 8 \
  --tool-call-parser hy_v3 \
  --reasoning-parser hy_v3 \
  --enable-auto-tool-choice \
  --served-model-name hy3-fp8

Quand choisir Hy3 ?

Hy3 convient aux équipes qui souhaitent :

• Contrôle total des données — auto-hébergé, aucune donnée ne quitte votre infrastructure
• Liberté commerciale — Apache 2.0, sans restrictions géographiques
• Tâches à contexte long — la fenêtre 256K gère les grandes bases de code, documents juridiques, articles de recherche
• Workflows agentiques — raisonnement entrelacé et appels d'outils conçus pour les agents multi-étapes
• Efficacité des coûts — 21 milliards de paramètres actifs, pas 295 milliards, signifie des coûts d'inférence gérables

La contrainte principale est le matériel : 8 GPUs à haute VRAM représente un investissement en capital réel.

Résumé

Tencent Hy3 est aujourd'hui la meilleure option open source pour le codage et le raisonnement en STEM. La licence Apache 2.0, une API compatible OpenAI et une profondeur de raisonnement configurable le rendent simple à intégrer dans tout projet TypeScript utilisant déjà le SDK OpenAI. Pointez baseURL vers votre endpoint vLLM et vous êtes opérationnel en quelques minutes.

La fiche modèle et les recettes vLLM sont disponibles sur github.com/Tencent-Hunyuan/Hy3.