Tencent Open-Sources Hy4 Preview: 770B Parameters, 49B Active, and a Million-Token Context for Coding and Research

On August 28, 2026, Tencent released and open-sourced Hy4 preview, a mixture-of-experts model with 770 billion total parameters, 49 billion active parameters, and a context window that exceeds one million tokens. Unlike the usual benchmark-focused launch, Tencent framed this release around real productivity work: software engineering, office and financial analysis, game development, and scientific research. For developers, three signals matter most: the weights are downloadable from Hugging Face, the million-token context finally makes whole-repository coding tasks practical on an open model, and the published API pricing makes long-context workloads something you can actually budget.

1. What Actually Shipped

Hy4 preview is an MoE model that activates roughly 49B of its 770B parameters per request. It is available through CodeBuddy, WorkBuddy, Yuanbao, and ima, and through the API via Tencent Cloud TokenHub and OpenRouter. At launch, WorkBuddy and CodeBuddy offered two free weeks, and free access to Hy3 was extended through September 30. In an internal blind evaluation where 163 experts scored 203 engineering tasks, Hy4 preview averaged 2.99 out of 4.00, slightly ahead of GLM-5.3 at 2.92 and Kimi K3 at 2.94. Caveat: that is a vendor-run evaluation, so treat the ordering as directional until third parties reproduce it.

# Download the open weights from Hugging Face.
# Hy4 preview ships alongside Hy3, so pin the repo revision.
pip install -U huggingface_hub
huggingface-cli download tencent/Hy4-preview --local-dir ./hy4-weights
# A quantized variant is the usual first stop for local testing:
huggingface-cli download tencent/Hy4-preview-FP8 --local-dir ./hy4-fp8

2. Why 49B Active Matters More Than 770B Total

The point of an MoE design is that per-request compute follows the active parameters, not the total count. With 49B active, inference costs land closer to a mid-size dense model while the 770B total supplies a much larger knowledge base. The bigger engineering variable, though, is the million-token context: it lets the model read the important files of a large repository, or cross-document financial material, before starting multi-step reasoning. For long-horizon software engineering, context length often decides success more than any single benchmark number.

// Before spending on GPU hours, estimate the real cost of your
// workload: active params matter more than total params for MoE.
function estimateMoECost(tokens, opts) {
  const activeB = opts.activeBillion || 49;
  const totalB = opts.totalBillion || 770;
  // MoE routes each token through the active subset, so the flops
  // per token scale with active parameters, not the full count.
  const flopsPerToken = 6 * activeB * 1e9;
  const totalFlops = tokens * flopsPerToken;
  return {
    activeShare: (activeB / totalB * 100).toFixed(1) + '%',
    totalFlops: (totalFlops / 1e18).toFixed(2) + ' EFLOPS',
    note: 'context length dominates memory, not compute'
  };
}

3. Positioned as a Productivity Model, Not an Autocomplete

Tencent explicitly pitches Hy4 preview at longer, open-ended analytical work. In software engineering it highlights stronger understanding, planning, debugging, and validation for long-context tasks, plus better visual quality and interaction in front-end work. In office and analytics scenarios it targets financial analysis and cross-document collaboration, covering the whole path from information processing to producing documents, spreadsheets, and presentations. In game development it can turn a single natural-language request into a playable prototype. For teams, the practical takeaway is to treat it as an analyst-style agent rather than a drop-in completion plugin.

// Hy4 preview API pricing (per million tokens), USD.
const HY4_PRICE = {
  input: 0.834,
  output: 2.501,
  cacheHit: 0.042, // cache reads are dramatically cheaper
};

function costPerTurn(inputTokens, outputTokens, cacheHits) {
  return (
    cacheHits * HY4_PRICE.cacheHit / 1e6 +
    (inputTokens - cacheHits) * HY4_PRICE.input / 1e6 +
    outputTokens * HY4_PRICE.output / 1e6
  ).toFixed(4);
}

// A 60k-token agent loop with 50k cached reads:
console.log(costPerTurn(60000, 4000, 50000)); // ~0.0218 USD

4. The Cost Picture: Long Context Finally Becomes Affordable

Published API pricing is USD 0.834 per million input tokens, USD 2.501 per million output tokens, and USD 0.042 per million cache-hit tokens. Cache reads cost about one-twentieth of fresh input, which is decisive for agent loops that re-read the same context every turn. A 60k-token agent turn with 50k cached reads lands near USD 0.022. Routing policy matters as much as model choice: send everyday coding to Hy3 and reserve Hy4 preview for long-horizon work. Budgeting tools that count tokens per request make this measurable instead of guesswork.

5. Self-Improvement and a 31.8% Throughput Gain

Tencent says Hy4 preview participated in its own development for the first time: the model was used to automate optimization of training methods, data strategies, evaluation frameworks, and low-level operators, forming an early recursive self-improvement loop. It also analyzed bottlenecks in its inference system and ran multiple rounds of operator-fusion and communication optimization, raising end-to-end throughput by 31.8% over baseline with consistent gains across context lengths and concurrency levels. For architects, the signal is that open-model release cycles will keep accelerating, because the model itself is now helping tune the deployment stack.

// Route tasks to the cheapest model tier that can finish them.
// Tencent ships Hy3 and Hy4 preview side by side, so route by
// difficulty instead of using one default for everything.
function pickModel(task) {
  if (task.ctxTokens > 900000 || task.depth === 'multi_repo') {
    return 'hy4-preview';   // million-token context, long-horizon work
  }
  if (task.kind === 'research' || task.kind === 'finance') {
    return 'hy4-preview';
  }
  return 'hy3';             // cheaper for everyday coding
}

6. What to Do Today

First, run your own eval: replay real repository tasks against Hy4 preview before changing defaults, and treat public scores as directional. Second, encode routing in code: switch between Hy3 and Hy4 preview based on context length and task difficulty rather than sharing one default. Third, estimate per-turn cost with the active-parameter and cache-hit math above instead of guessing. Finally, remember that million-token contexts cost memory as well as compute: check GPU memory headroom before you assume long-context is free.

// Run your own blind eval before adopting any open model.
// Public claims are directional; your tasks are the contract.
const evalTasks = [
  { id: 'fix-crash', prompt: 'Root-cause this intermittent failure', ctx: 820000 },
  { id: 'refactor-module', prompt: 'Refactor legacy module with tests', ctx: 150000 },
  { id: 'finance-report', prompt: 'Summarize this earnings call', ctx: 40000 },
];

async function runEval(model) {
  const results = [];
  for (const t of evalTasks) {
    const ok = await executeTask(model, t);   // your harness
    results.push({ task: t.id, passed: ok, cost: costPerTurn(t.ctx, 4000, 0) });
  }
  return results;
}