Hy4 Preview API: 770B MoE Specs, Benchmarks & Claude Code Setup

On August 28, 2026, Tencent officially open-sourced Hy4 preview (Hunyuan 4), establishing a new frontier for open-weight Mixture-of-Experts (MoE) foundation models. Built specifically for automated code refactoring, document synthesis, and multi-step autonomous agent loops, this architecture delivers massive capacity with sparse computational efficiency.

However, developers trying to connect the model to CLI agents like Claude Code or IDEs like Cursor face steep infrastructure roadblocks: stringent rate limits on experimental endpoints, regional card decline walls on domestic cloud consoles, and schema incompatibilities between OpenAI chat payloads and raw MoE endpoints.

Through APIVALE’s Unified API Gateway, developers can claim an instant $0.20 free starter credit and immediately invoke infer/hy4-preview with native OpenAI and Anthropic endpoint compatibility, high-concurrency routing, and zero-KYC PayPal Global Billing (Credit Cards, PayPal, and international wallets).

What is Hy4 Preview? 770B MoE Architecture & Technical Specs

The flagship transformer engine is engineered for high-throughput reasoning and production code synthesis.

Architectural Breakdown: Dense vs. Sparse Routing

Unlike traditional dense models that execute all weights for every generated token, fine-grained expert routing maintains high inference velocity while scaling overall knowledge capacity:

graph TD
    User["Developer Client / Agent (Claude Code / Cursor / Script)"] --> APIVALE["APIVALE Unified Gateway (https://apivale.com/v1)"]
    
    subgraph "APIVALE High-Availability Router"
        APIVALE --> Auth["Zero-KYC Waffo Billing & Auth Engine"]
        Auth --> Cache["Prompt Cache & Token Accelerator"]
        Cache --> Adapter["Protocol Adapter (OpenAI / Anthropic Messages)"]
    end
    
    subgraph "Inference Pool Failover Cluster"
        Adapter --> NodeA["Primary Hy4-Preview Cluster (FP8 MoE 770B)"]
        Adapter --> NodeB["Secondary Failover Cluster (OpenRouter / Cloud)"]
        Adapter --> NodeC["Fallback Model: Kimi K3 / Qwen 3.8"]
    end
    
    NodeA --> Resp["Sub-420ms TTFT SSE Stream"]
    Resp --> User

Verified Benchmarks: Hy4 Preview vs Kimi K3 Benchmarks

In comprehensive engineering benchmarks evaluating multi-file refactoring, terminal error diagnosis, and long-context code comprehension (up to 1M tokens), the model shows substantial precision gains over prior open-source flagships.

Engineering & Coding Benchmark Results

In blind A/B evaluation datasets encompassing 203 end-to-end coding tasks:

• Real-World Code Generation (SWE-bench Verified): Achieved a 48.6% resolve rate, competing directly with proprietary frontier models.
• 1M Context Needle-in-a-Haystack: 100% retrieval accuracy up to 800k tokens, maintaining 99.4% accuracy across the full 1,000,000 token limit.
• Inference Latency & TTFT: When served via APIVALE’s edge infrastructure, the cluster delivers a Time-To-First-Token (TTFT) of 390ms and sustained generation throughput of 58 tokens/second.

Hy4 Preview API Pricing & Arbitrage Model

Direct access via cloud portals often involves tiered minimums or payment frictions. APIVALE offers pay-as-you-go token pricing settled via Waffo Global Billing:

$$\text{Total Cost} = \left( \frac{\text{Prompt Tokens}}{1,000,000} \times $0.25 \right) + \left( \frac{\text{Completion Tokens}}{1,000,000} \times $0.85 \right)$$

Compared to commercial closed APIs ($3.00 / $15.00 per 1M tokens), using APIVALE as your primary hy4 preview openrouter alternative cuts monthly API spend by up to 85% without compromising on coding performance.

Interactive Hy4 Preview Token Cost & Agent Savings Calculator

Estimate your monthly API expenditure when running autonomous developer agents (e.g. Claude Code CLI, Cursor Composer, or custom AutoGPT pipelines):

<div>
  <label for="hy4-output-tokens" class="block text-xs font-semibold text-gray-400 uppercase tracking-wider mb-2">Monthly Output Tokens (Millions)</label>
  <input type="range" id="hy4-output-tokens" min="0.5" max="25" step="0.5" value="5" class="w-full h-2 bg-gray-800 rounded-lg appearance-none cursor-pointer accent-emerald-500" oninput="calculateHy4Cost()">
  <div class="flex justify-between text-xs text-gray-400 mt-1">
    <span>0.5M</span>
    <span id="hy4-output-val" class="text-emerald-400 font-bold font-mono">5.0M tokens</span>
    <span>25M</span>
  </div>
</div>

How to Connect Hy4 Preview to Claude Code CLI

Anthropic’s Claude Code CLI enables autonomous command-line agent execution. APIVALE provides an Anthropic Messages protocol translation layer, allowing you to run infer/hy4-preview directly without altering codebase workflows.

Step 1: Obtain Your APIVALE Key

1. Sign up on the APIVALE Console.
2. Top up balance instantly using Waffo Global Billing (Credit Cards, PayPal, Apple Pay, Google Pay).
3. Generate a production API Key.

Step 2: Configure Environment Variables

Export the proxy endpoint and target model in your shell configuration (~/.bashrc, ~/.zshrc, or PowerShell):

# Set APIVALE Anthropic-compatible Base URL
export ANTHROPIC_BASE_URL="https://apivale.com/v1"
export ANTHROPIC_API_KEY="sk-apivale-your-api-key-here"

# Route Claude Code to Hy4 Preview
export CLAUDE_CODE_MODEL="infer/hy4-preview"
export CLAUDE_CODE_SUBAGENT_MODEL="infer/hy4-preview"

For Windows PowerShell users:

$env:ANTHROPIC_BASE_URL="https://apivale.com/v1"
$env:ANTHROPIC_API_KEY="sk-apivale-your-api-key-here"
$env:CLAUDE_CODE_MODEL="infer/hy4-preview"

Step 3: Launch and Verify Execution

claude "Analyze this repository architecture and identify memory leak risks in the worker pool"

How to Use Hy4 Preview in Cursor IDE

To use the 770B MoE engine for Cursor Composer, inline edits, and terminal agent queries, configure APIVALE as a custom OpenAI endpoint:

Step 1: Override OpenAI Endpoint in Cursor

1. Open Cursor Settings (Cmd + Shift + J or Ctrl + Shift + J) $\rightarrow$ Models.
2. Toggle on Override OpenAI Base URL and enter:

   https://apivale.com/v1

3. Paste your APIVALE API key into the OpenAI API Key field and click Save.

Step 2: Add Custom Model Identifier

1. Under Model Names, click + Add Model.
2. Enter the model ID: infer/hy4-preview.
3. Enable it as your active model.

Step 3: Configure .cursorrules for 1M Context Reasoning

Add the following .cursorrules file to your project root:

{
  "cursorRules": {
    "role": "Senior Distributed Systems & MoE Architect",
    "contextBudget": "1000000_tokens",
    "guidelines": [
      "Leverage full 1M context to inspect entire dependency graphs before refactoring.",
      "Output complete, production-grade code without truncating snippets or omitting imports.",
      "Include explicit error handling for high-concurrency SSE stream connections."
    ]
  }
}

Production Integration: Python Async Client with Exponential Backoff

When executing autonomous loops across millions of tokens, resilient error handling is vital. This production Python client demonstrates calling infer/hy4-preview via APIVALE with asynchronous streaming and retry management:

import asyncio
import os
import sys
from openai import AsyncOpenAI, APIConnectionError, RateLimitError, APIStatusError

# Initialize Async Client configured for APIVALE Gateway
client = AsyncOpenAI(
    base_url="https://apivale.com/v1",
    api_key=os.getenv("APIVALE_API_KEY", "sk-apivale-demo-key"),
    timeout=60.0,
    max_retries=0  # Managed explicitly in application logic
)

async def stream_hy4_completion(prompt: str, max_retries: int = 4):
    """
    Streams tokens from Hy4 Preview with exponential backoff for high-load resilience.
    """
    backoff_delay = 1.0
    for attempt in range(1, max_retries + 1):
        try:
            print(f"[*] Sending prompt to Hy4 Preview (Attempt {attempt}/{max_retries})...")
            stream = await client.chat.completions.create(
                model="infer/hy4-preview",
                messages=[
                    {"role": "system", "content": "You are an expert software engineer optimizing high-scale cloud systems."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.2,
                max_tokens=4096,
                stream=True
            )
            
            print("[+] Streaming response:\n" + "=" * 50)
            async for chunk in stream:
                content = chunk.choices[0].delta.content or ""
                sys.stdout.write(content)
                sys.stdout.flush()
            print("\n" + "=" * 50 + "\n[+] Generation completed successfully.")
            return

        except (RateLimitError, APIConnectionError, APIStatusError) as e:
            print(f"[-] Request failed (Error: {type(e).__name__}): {e}")
            if attempt == max_retries:
                print("[!] Max retries exceeded. Request aborted.")
                raise e
            print(f"[*] Backing off for {backoff_delay:.2f} seconds before retrying...")
            await asyncio.sleep(backoff_delay)
            backoff_delay *= 2.0

if __name__ == "__main__":
    test_prompt = "Write an optimized Rust actor system handling 100,000 WebSocket connections with backpressure."
    asyncio.run(stream_hy4_completion(test_prompt))

Edge-Case & Error Troubleshooting (429, 504 & Billing Fixes)

1. Fixing HTTP 429 Too Many Requests

• Root Cause: Free public endpoints or single-provider accounts throttle concurrent connections during large batch prompts.
• Resolution: Route traffic through https://apivale.com/v1. APIVALE balances queries across multiple high-capacity MoE clusters, eliminating artificial concurrency throttling.

2. Fixing HTTP 504 Gateway Timeout on 1M Context Prompts

• Root Cause: Processing 500k+ tokens in a single request can exceed standard 30-second client timeouts before first-token delivery.
• Resolution: Increase HTTP socket timeout to at least 120 seconds (timeout=120.0) and ensure SSE streaming (stream=True) is active.

3. Resolving International Payment Decline Blocks

• Root Cause: Domestic model consoles frequently mandate mainland payment channels and SMS verification.
• Resolution: Use Waffo Global Billing on APIVALE. Recharge balance with standard international credit cards, PayPal, or digital wallets with zero KYC verification.

Frequently Asked Questions (FAQ)

Is Hy4 preview open source?

Yes, the model is released under the Apache 2.0 open-source license with weights on Hugging Face and ModelScope. For instant cloud inference without multi-GPU clusters, developers can invoke infer/hy4-preview on APIVALE.

How does Hy4 preview compare to Kimi K3 and GLM-5.3?

In internal blind engineering evaluations across 203 tasks, the engine scored 2.99/4.00 compared to 2.94 for Kimi K3 and 2.92 for GLM-5.3, featuring a full 1,000,000 token context window.

How can I pay for Hy4 preview API tokens with PayPal or Credit Cards?

APIVALE integrates Waffo Global Billing, enabling top-ups via PayPal, credit cards, Apple Pay, and Google Pay with zero identity verification (zero-KYC).

Can I use Hy4 preview in Claude Code CLI and Cursor?

Yes. APIVALE natively abstracts OpenAI and Anthropic API protocols. Point your endpoint to https://apivale.com/v1, set your model to infer/hy4-preview, and start coding immediately.