Tencent Hy4

Tencent Hy4 is Tencent's flagship open-weight multimodal model, released on November 4, 2026. Built as an expansive Mixture-of-Experts (MoE) system, it scales to 770 billion total parameters while activating only 49 billion parameters per token. Featuring integrated text-and-vision capabilities alongside a massive 1,048,576 token context window, Hy4 is built specifically for deep reasoning, long-horizon autonomous tasks, and multimodal computer operation.

The release marks a significant milestone for enterprise teams looking for a local AI model 770B parameters 2026 alternative to proprietary frontier APIs. Rather than limiting the architecture to standard text interactions, Tencent designed Hy4 from the ground up to tackle visual perception, complex codebases, document comprehension, and cross-application workflows across both command-line interfaces (CLI) and graphical user interfaces (GUI).

For practitioners evaluating whether to run Tencent Hy4 locally, this model bridges the gap between massive parameter capacity and operational throughput. The sparse MoE gating keeps per-token compute demands close to a mid-sized dense model, though the memory footprint required to store all 770 billion parameters demands serious hardware planning.

Hy4 relies on a sparse Mixture-of-Experts backbone consisting of 78 layers. The initial layer operates as a standard dense feed-forward network (FFN), while the subsequent 77 layers utilize MoE routing. Each MoE layer contains 256 routed experts and one shared expert. For any single token forward pass, the router selects the top-8 routed experts in addition to the shared expert, yielding an active compute footprint of 49 billion parameters.

This design creates a distinct operational split:

• Total Parameters (770B): Governs memory capacity requirements. All 770 billion weights must be accessible in VRAM or system RAM for inference.
• Active Parameters (49B): Governs execution speed and arithmetic processing. Hy4 computes tokens at the latency profile of a 49B model rather than a 770B dense model.

To handle its 1,048,576 token context window efficiently, the architecture integrates Gated DeepSeek Sparse Attention (Gated DSA) paired with IndexCache for cross-layer sparse index reuse. The residual pathway uses identity Hyper-Connections (iHC) to preserve gradient and feature fidelity across deep layers. In addition, Hy4 includes an integrated native Multi-Token Prediction (MTP) layer (10B total parameters, 0.7B activated) to accelerate speculative decoding during production inference runs.

The context length of over one million tokens allows practitioners to ingest hundreds of pages of documentation, entire software repositories, or hours of interaction traces in a single prompt without chunking or external retrieval degradation.

Hy4 is optimized for agentic workloads that demand both visual and structured programmatic execution:

• Computer Use and GUI Automation: Hy4 incorporates visual understanding with tool execution to interact with software environments. It can analyze high-resolution screenshots, locate interface elements, and issue commands across both CLI and complex desktop applications like CAD and Blender.
• Tencent Hy4 for Coding and Game Development: Co-developed alongside game engineers from Tencent Interactive Entertainment Group (IEG), the model specializes in production-ready frontend development, full-stack state management, game logic scripting, and repository-wide refactoring.
• Visual Document and Chart Analysis: The visual encoder processes fine-grained image details, extracting tabular data, complex diagrams, architectural layouts, and high-resolution satellite imagery directly into reasoning workflows.
• Extended Reasoning and Math: In complex problem solving, Hy4 relies on extended internal deliberation paths to navigate multi-step mathematical problems and multi-stage logic proofs.
• Function Calling and Instruction Following: The model supports structured JSON output and reliable function calling out of the box, making it well-suited for autonomous multi-agent pipelines.

Deploying a model of this scale locally requires careful capacity planning. Because every weight must be stored in memory to route tokens dynamically, Tencent Hy4 VRAM requirements represent the primary bottleneck for on-premise infrastructure.

To run the model, you need sufficient memory to hold the model weights plus an additional allocation for the KV cache, which grows significantly when tapping into the 1M context window.

• FP16 / BF16 (16-bit): Requires roughly 1.5 TB to 1.6 TB of VRAM. This configuration mandates dedicated multi-GPU clusters (such as 8x or 16x NVIDIA H100, H200, or B200 141GB/192GB nodes).
• Q8_0 (8-bit): Requires approximately 800 GB to 850 GB of VRAM. Achievable on an 8x 96GB/141GB enterprise GPU node.
• Q4_K_M (4-bit): Requires roughly 430 GB to 480 GB of memory just for the weights. A realistic deployment with context headroom requires 512 GB to 640 GB of total addressable memory.

Practitioners frequently ask how to run 770B model on consumer GPU setups. A standard workstation card like an NVIDIA RTX 4090 (24GB) cannot run Hy4 independently. Even pooling four RTX 4090 cards yields only 96GB of VRAM, which falls well short of the ~450GB threshold needed for 4-bit execution.

For local, non-cloud execution, your hardware choices generally fall into two categories:

1. Enterprise Multi-GPU Nodes: The best GPU for Tencent Hy4 in production environments is an array of NVIDIA H200 (141GB) or B200 (192GB) GPUs running tensor and pipeline parallelism. A node with four H200s or eight A100/H100 80GB cards can serve the 4-bit quantized model with extensive KV cache headroom.
2. Unified Memory Workstations: High-end Apple Silicon hardware configured with unified memory can load the model at 4-bit precision. For example, clustered Mac Studio devices or custom multi-socket enterprise CPU servers with 512GB to 1TB of high-bandwidth system RAM can host the weights, though token generation speeds will be bounded by memory bandwidth.

For most practitioners outside hyperscale data centers, Q4_K_M is the recommended format. It cuts the memory footprint by over 65% compared to FP16 while preserving the model's reasoning and coding capabilities. If deploying on enterprise servers with constrained memory, AWQ or EXL2 4-bit formats provide optimal throughput under vLLM or SGLang.

Thanks to Tencent Hy4 MoE efficiency, once the weights are addressed, compute throughput is relatively agile:

• Enterprise 8x GPU Clusters (Tensor Parallelism via vLLM): Expect 35 to 70+ Tencent Hy4 tokens per second under Q4 or FP8 precision, depending on concurrent batch sizes and active context length.
• High-RAM Workstation Offload (CPU / Unified Memory): Processing speeds drop significantly due to lower memory bandwidth, typically yielding between 1.5 and 6 tokens per second at 4-bit quantization.

For high-throughput multi-GPU deployments, serving Hy4 via vLLM or SGLang is recommended to properly leverage tensor parallelism and the native MTP speculative decoding layer.

If you are testing the model locally on high-RAM unified memory systems, Ollama provides the most straightforward path. Once a compatible GGUF quantization is imported into your local manifest, run:

1ollama run tencent-hy4:latest

Ensure your Ollama configuration allocates sufficient scratchpad space and system swap headroom before initializing the context.

Understanding where Hy4 sits against other open-weight heavyweights helps identify the right use case.

DeepSeek V3 utilizes a 671B parameter MoE architecture activating 37B parameters per token, making it slightly smaller than Hy4. While DeepSeek V3 offers exceptional code generation and competitive math benchmark results, Hy4 provides two concrete architectural advantages: native visual perception and a 1M token context window (compared to DeepSeek's 128k context). If your pipeline is strictly text-based code refactoring, DeepSeek V3 requires less memory to run locally. If your workload involves document inspection, UI screenshots, or massive multi-file context tracking, Hy4 is the broader tool.

On long-horizon SWE benchmarks and file refactoring tests like SWE Atlas and OneMillionBench, Hy4 demonstrates superior context retention compared to GLM 5.3 and Kimi K3. On pure math and abstract reasoning benchmarks, top-tier frontier models maintain a slight edge. However, Hy4's targeted post-training for desktop application use (CAD, 3D modeling, GUI navigation) makes it distinctly better suited for agentic desktop automation and multimodal tooling workflows.