Hy4-preview

Hy4 preview

Seven hundred and seventy billion parameters, forty-nine active — and an evaluation that publishes its losses.

The Evaluation Publishes Its Losses

The number worth reading first, because of what it includes rather than what it claims.

A blind side-by-side evaluation: 163 internal experts rating model outputs on 203 engineering tasks.

Four in ten comparisons went the other way, and Tencent publish that alongside the margin.

Most vendor comparisons report the aggregate and stop. A 2.99 against a 2.94 sounds like a settled result; a 51.2% win rate against a 40.9% loss rate tells you it is close enough that the model you should use depends on the task.

And the methodology is the other half. Blind, side by side, 163 raters, and the raters are domain experts rather than crowd workers — on engineering tasks rather than benchmark questions.

Which makes it a different kind of evidence from a benchmark score. It measures whether people who do this work preferred the output, which is closer to what you want to know and harder to game.

Read the loss rate as the useful figure. On four tasks in ten, an expert preferred something else — and the honest reading of that is "comparable," not "better."

Trained on Work That Ships

The data sourcing is named specifically, and the specificity is the point.

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.

Four professions, named. Not "high-quality data" or "curated corpora" — four groups of people who produce something for a living, and training material built from what they produce.

Why that matters more than volume. Scraped code teaches a model what code looks like. Code that shipped teaches it what code that survived review looks like — which is a different distribution, and the one a production assistant needs to match.

The same logic applies to the other three. Game development, financial analysis, and security work each have conventions that do not appear in public text at the density they appear in professional practice.

And the products close the loop. The model is co-designed with Tencent's own developer and workplace tools, so improvements show up in the work people do with it rather than only on a leaderboard.

Which explains the evaluation design. A model trained on shipped work, embedded in working tools, evaluated by the people who do the work. The three decisions are one decision.

Ship Early, On Purpose

Stated plainly on the model card, and it is a positioning statement rather than a disclaimer.

This is an early version of Hy4. As with the previous preview, we would rather ship early and hear what breaks — that's what made the last generation substantially better, and it's how we will get this one right.

Three things follow from taking that at face value.

Behaviour will change. A preview is a checkpoint in an ongoing process, not a fixed artefact. A prompt suite tuned against it may need re-validating when the full release arrives.

Your findings are the intended contribution. The card names an open-source contact address and says what it wants — reports of what breaks.

And the previous generation is cited as evidence the process works. "That's what made the last one substantially better" is a claim you can check against that model's release history rather than only trust.

None of this makes it unusable. It makes it a model to evaluate and report on rather than to deploy and forget.

Architecture

Forty-nine billion of 770 — roughly six percent per token, and a high activation count in absolute terms.

The drafter is counted separately

One native multi-token-prediction layer, with its own parameter budget: 10 billion total, 0.7 billion activated.

Most models mention speculative decoding and leave the drafter's cost unstated. Publishing it separately is unusually precise, and it tells you two things.

The drafter is small relative to the backbone — 0.7 billion active against 49 billion. Drafting seven-tenths of a billion parameters' worth of prediction to save a 49-billion-parameter forward pass is a favourable ratio, which is the whole economics of speculative decoding.

And it is native rather than a separate model to deploy. No second checkpoint, no separate serving process, no version-matching between draft and target.

Scaled on three fronts

Model size, context length, and training data — named together, which is how a generation-over- generation gain is usually produced. No single axis, three at once.

Tencent describe the result as the largest generation-over-generation gain they have measured, with stronger pre-training and a substantially larger post-training run compounding.

Specifications

Apache 2.0 on a 770-billion-parameter flagship. Commercial use, modification, and redistribution with no conditions, no attribution requirement, and no user threshold — at a scale where custom licences are common.

An official FP8 checkpoint is published alongside the full-precision weights.

A complete fine-tuning pipeline ships with the model, which is a meaningful addition at this scale — the weights being open does not by itself make training on them practical.

Capabilities

Using Hy4 preview on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: tencent/Hy4-preview

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="tencent/Hy4-preview",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=1024,
)

print(response.choices[0].message.content)

Node.js

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    model: "tencent/Hy4-preview",
    messages: [{ role: "user", content: "Hello world!" }],
    max_tokens: 1024,
  });

  console.log(response.choices[0].message.content);
}

main();

cURL

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tencent/Hy4-preview",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

Engineering Work

The domain the training data and the evaluation both target.

SYSTEM = """You are reviewing a change before it merges.

Report only defects that would cause incorrect behaviour, data loss, or a security issue. Style,
naming, and preference are out of scope.

For each finding: the file and line, the condition that triggers it, the consequence, and the
smallest correct fix.

Where the diff does not contain enough context to judge something, say what you would need to see
rather than assuming."""

response = client.chat.completions.create(
    model="tencent/Hy4-preview",
    messages=[
        {"role": "system", "content": SYSTEM},
        {"role": "user", "content": diff},
    ],
    max_tokens=16384,
    temperature=0.2,
)

Scoping the review to correctness is what makes the output actionable. A review that mixes a race condition with a naming preference buries the one that matters.

And the last clause is the one that separates a useful reviewer from a confident one. A diff shows changed lines, not the code around them — and a model that flags what it cannot see is more useful than one that guesses at it.

This is the shape of task the model was evaluated on. Two hundred and three engineering tasks, rated by people who do engineering — which makes your own engineering tasks the right thing to evaluate it against.

Reading the Reasoning

message = response.choices[0].message

trace = getattr(message, "reasoning_content", None)
if trace:
    logger.debug("reasoning: %d characters", len(trace))

print(message.content)

Keep the fields apart in both directions. Merging the trace into the answer breaks structured-output parsing and puts a working draft in front of readers expecting a conclusion.

Check finish_reason. Reasoning shares the output budget, and a truncated response can contain a complete trace and no answer at all.

An Agent Loop

import json
import time

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read a file relative to the repository root.",
            "parameters": {
                "type": "object",
                "properties": {"path": {"type": "string"}},
                "required": ["path"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "run_tests",
            "description": "Run the test suite and return pass/fail counts with failure output.",
            "parameters": {"type": "object", "properties": {}},
        },
    },
]


def read_file(path: str) -> dict:
    """Replace with your real, sandboxed file access."""
    raise NotImplementedError


def run_tests() -> dict:
    """Replace with your real, sandboxed test runner."""
    raise NotImplementedError


HANDLERS = {"read_file": read_file, "run_tests": run_tests}

session = [
    {
        "role": "system",
        "content": (
            "You are working inside a git repository. Investigate before changing anything, and run "
            "the tests after every edit. If a failure is not explained by your last change, say so "
            "and stop rather than guessing."
        ),
    },
    {"role": "user", "content": "The DZD invoice test fails on totals ending in .005. Find the cause."},
]

CEILING = 60
start = time.monotonic()

for step in range(CEILING):
    response = client.chat.completions.create(
        model="tencent/Hy4-preview",
        messages=session,
        tools=TOOLS,
        max_tokens=16384,
    )

    message = response.choices[0].message
    session.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        session.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})
else:
    print(f"Stopped at the {CEILING}-step ceiling.")

print(f"{step + 1} steps, {(time.monotonic() - start) / 60:.1f} min")

"Say so and stop rather than guessing" is the instruction worth keeping on a preview model. Behaviour on edge cases is exactly what a preview has not settled, and an agent that escalates confusion to a person is one you can leave running.

Evaluating It Yourself

The model card asks for this, and on a preview it is the useful contribution.

CANDIDATES = ["tencent/Hy4-preview", "<another model in your catalogue>"]


def compare(prompt: str, system: str) -> None:
    """Run the same task on two models and report tokens and latency."""
    import time

    for model in CANDIDATES:
        start = time.monotonic()
        response = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": system},
                {"role": "user", "content": prompt},
            ],
            max_tokens=16384,
            temperature=0.2,
        )
        elapsed = time.monotonic() - start

        print(f"{model:<28} {response.usage.completion_tokens:>7,} tokens  {elapsed:>6.1f}s")
        print(response.choices[0].message.content[:400])
        print("---")

Blind, side by side, on your own tasks is exactly the methodology Tencent used — and at a much smaller scale it is still the right one. Print both outputs, read them without knowing which is which, and pick.

Twenty tasks is enough to see a pattern. The published 51/8/41 split says the answer is task-dependent, which means your tasks are the ones that decide it.

And report what breaks. The card names a contact address and says that is what made the previous generation better.

Self-Hosting

A 770-billion-parameter model is a multi-node proposition, and the release is unusually well equipped for it.

Official prebuilt images

Both major serving frameworks ship tagged images for this model specifically, rather than leaving you to assemble a stack — and the SGLang image is multi-architecture, covering x86 and Arm.

That Arm support is worth noting. Frontier-scale models are almost always x86-only in practice, and a published Arm image is a different deployment surface.

Three flags that are not optional

--load-format hy4_safetensors — a custom load format. The standard safetensors loader does not read these weights.

--reasoning-parser hy_v4 — without it, reasoning traces leak into the visible answer rather than arriving in their own field.

--enable-expert-parallel — required at this expert count, alongside an all-to-all backend and expert weight filtering in the reference configurations.

Scale

Reference community deployments run four nodes with sixteen-way tensor parallelism and two-way pipeline parallelism, at high GPU memory utilisation.

The FP8 checkpoint is the practical starting point, published by Tencent directly.

Cross-chip validation

The model has been adapted, precision-aligned, and deployment-validated across several AI accelerator families by an external community effort — with images published per chip.

Which is unusual and worth knowing if your hardware is not NVIDIA. Most frontier open models are validated on one vendor's silicon; this one has published, tested paths across several.

And the same effort published comparison metrics per chip, so the cost of moving off the reference hardware is documented rather than discovered.

Where It Fits

Engineering work, which the training data and the evaluation both target directly.

Code review, debugging, and repository-scale reasoning, evaluated by engineers on engineering tasks.

Financial analysis, game development, and security work — the other three professions named in the data sourcing.

Agentic workflows, with native speculative decoding keeping long sessions affordable.

Self-hosted deployment under Apache 2.0, with official serving images, a fine-tuning pipeline, and validated paths across several accelerator families.

Evaluation and feedback, which is what a preview is for and what its authors ask for.

Not for production paths that cannot absorb change. It is an early version and says so.

Not for vision. Text only.

Not where one vendor's benchmark is your decision criterion. The published evaluation is honest about being close, and your own comparison is the one that settles it.

Practical Notes

Read the evaluation's loss rate, not only its margin — four in ten went the other way.

Run your own blind comparison on twenty of your real tasks.

Report what breaks; the card asks for it and names a contact.

Instruct agents to stop on unexplained failures rather than guessing.

Check finish_reason — reasoning shares the output budget.

If self-hosting: the custom load format, the hy_v4 reasoning parser, and expert parallelism are all required.

Start from the FP8 checkpoint.

Check the cross-chip images if your hardware is not NVIDIA.

Re-validate your prompts when the full release arrives.

Limitations

A preview, explicitly. Behaviour will change, and Tencent frame that as the point rather than a caveat.

The published comparison is close. 51.2% wins against 40.9% losses is a narrow result, and the model that suits a given task is task-dependent.

Evaluated on engineering tasks by internal experts. That is the right axis for engineering work and a narrow one for everything else.

Text only. No image, audio, or video input.

Forty-nine billion active parameters is the compute ceiling per token.

770 billion parameters must be loaded — the MoE saving is in compute, not memory, and self-hosting is a multi-node proposition.

A custom load format and a model-specific reasoning parser are both required. Neither fails gracefully.

Reasoning traces are working notes. Unpolished, sometimes exploring abandoned branches, and occasionally contradicting the answer that follows.