SiliconFlow Hy4 Preview Puts a 770B Open Model Behind a Familiar API

SiliconFlow has added Hy4 preview, Tencent's 770-billion-parameter open model, to its platform with a claimed one-million-token context window. The SiliconFlow Hy4 preview listing turns an unusually large open-weight release into an API option for developers using established coding and agent tools.

That availability matters because Hy4 preview is difficult to serve independently. Its published weights occupy more than a terabyte, while Tencent's deployment recipe assumes an eight-GPU configuration for the compressed FP8 version. SiliconFlow is effectively offering access without requiring each team to assemble that infrastructure.

The result creates a direct test between open weights and managed proprietary models. Claude, Codex, and other hosted systems combine model capability with tightly controlled infrastructure. Hy4 preview offers inspectable weights and broader deployment rights, but its real-world reliability remains less established.

SiliconFlow Hy4 Preview Removes the First Deployment Barrier

SiliconFlow changes Hy4 preview from a downloadable research artifact into a model that ordinary API customers can evaluate inside existing workflows.

The company announced the addition through its Hy4 platform post. According to that post, customers can connect the model to Claude Code, Codex, Cursor, and other tools that accept compatible model endpoints.

That integration path matters more than another benchmark chart. Most developers do not begin a model evaluation by building an inference cluster. They begin by replacing an endpoint inside a workflow they already understand.

A coding team can route a bounded repository task to Hy4 preview and compare its patch with an incumbent model. An analyst can test whether the larger context holds together across reports, spreadsheets, and supporting documents. A research group can examine its reasoning across a long collection of papers and notes.

The model itself comes from Tencent's Hy team, not SiliconFlow. Tencent released the weights under Apache 2.0 and described Hy4 preview as a productivity-focused flagship model. SiliconFlow supplies managed inference and the interface through which customers can use it.

This separation is important. Tencent controls the model design, training claims, weights, and official documentation. SiliconFlow controls the hosted service experience, including availability, throughput, caching, limits, and operational behavior.

The announcement therefore verifies platform availability, not every possible performance claim. SiliconFlow's post does not establish that the hosted model matches proprietary systems across real production workloads. It also does not independently validate Tencent's internal evaluations.

Still, managed access removes the largest initial obstacle. Tencent's model repository includes deployment instructions, but those instructions target teams with substantial accelerator capacity and inference expertise.

The full model contains 770 billion backbone parameters. Its mixture-of-experts architecture activates only 49 billion for each token, reducing computation compared with activating the entire model. That design does not make storage or serving requirements disappear.

Tencent also publishes an FP8 version, which stores model values with reduced numerical precision. FP8 can lower memory use and improve throughput, although deployment results depend on hardware, kernels, batching, and workload shape.

The hosted route lets developers examine outputs before committing to those engineering costs. That makes SiliconFlow Hy4 preview relevant even for organizations that ultimately want to self-host the model.

An API evaluation can answer practical questions first. Teams can measure instruction adherence, tool calling, code quality, latency, and failure recovery. They can then decide whether control over the weights justifies a more demanding deployment.

SiliconFlow also places the model inside an expanding market for interchangeable inference providers. In that market, model access becomes less tied to a single application. Developers can keep their interface while changing the system behind it.

That portability has limits. Each model handles reasoning controls, tool schemas, token counting, and error conditions differently. Endpoint compatibility reduces migration work, but it does not guarantee identical application behavior.

The immediate change is therefore narrow but meaningful. Hy4 preview is no longer available only to teams ready to manage a very large model. It can now enter ordinary model-routing experiments.

Why 770B Parameters Do Not Mean 770B Parameters per Token

Hy4 preview uses scale for stored knowledge and specialization while limiting the portion of the network used for each generated token.

Tencent describes Hy4 preview as a mixture-of-experts model, commonly shortened to MoE. An MoE system contains many specialized feed-forward components, while a routing mechanism selects a smaller subset during inference.

The official model card lists 770 billion backbone parameters and 49 billion activated parameters per token. It contains 78 backbone layers, with 256 routed experts and one shared expert in most layers.

For each token, the router selects eight routed experts alongside the shared expert. This arrangement seeks a middle ground between model capacity and inference cost. The entire network can store learned behavior, while each token uses a smaller computational path.

That distinction prevents a common misunderstanding. Total parameter count describes the overall network, not the exact computation required for every token. Active parameters provide a more useful starting point for estimating inference work in an MoE model.

However, active parameter count is not a complete cost metric. The service still needs access to the much larger collection of weights. Moving data between memory and compute devices can become a major bottleneck.

Expert routing also creates operational challenges. Requests may not distribute evenly across experts, especially under variable workloads. Providers must manage memory placement, parallelism, batching, communication overhead, and specialized kernels.

Hy4 preview adds a native multi-token-prediction layer for speculative decoding. This technique proposes several future tokens before the main decoding process verifies them. When the proposals are accepted, the system can produce output with fewer sequential steps.

Tencent says this additional layer contains 10 billion total parameters and activates 700 million. Those figures sit outside the published 770-billion-parameter backbone specification.

The model also uses a sparse attention design inspired by work associated with DeepSeek and GLM. Sparse attention reduces the number of earlier tokens examined directly during each step. This matters when a prompt approaches an extremely long context limit.

Dense attention compares each relevant token with every other token, creating steep compute and memory requirements as input grows. Sparse methods select a narrower set of positions, aiming to retain useful information with less work.

Tencent identifies its implementation as Gated DeepSeek Sparse Attention with IndexCache. The company says IndexCache reuses sparse indexes between layers. These choices are intended to make long inputs more manageable.

A one-million-token context window is the model's most visible specification. Context window means the maximum combined input and generated sequence the model can process under supported conditions.

That limit does not mean every answer will use one million tokens accurately. Maximum acceptance, useful retrieval, reasoning consistency, latency, and cost are different properties. A model can accept a long prompt while overlooking decisive details inside it.

The specification still creates useful possibilities. A developer might supply a large repository, issue history, architecture documents, and test logs in one session. An analyst might combine several years of filings and internal research.

Knowledge workers face a related challenge. Their information is often scattered across documents, meetings, notes, and local files. A personal knowledge base can organize that material before any model receives it.

Organization remains necessary because indiscriminate context can hurt results. Duplicated documents, outdated decisions, irrelevant logs, and conflicting instructions increase the model's burden. A larger window expands capacity but does not replace information selection.

Hy4 preview defaults to a high reasoning mode in Tencent's published configuration. Developers can request a direct-response mode when extended reasoning is unnecessary. That choice affects responsiveness and makes workload-level testing essential.

The mechanism behind Hy4 preview is therefore more interesting than its headline parameter count. Tencent combines many experts, sparse attention, and speculative decoding to make an enormous open model usable.

SiliconFlow's role is to determine whether that architecture feels practical through an API. For customers, output quality per unit of time matters more than the elegance of the underlying design.

Open Weights Challenge the Managed Model Bundle

The main contest is not Hy4 preview against one named model, but open deployment rights against vertically controlled AI services.

Proprietary model providers sell more than model intelligence. They also provide optimized serving, safety systems, observability, support, stable interfaces, and integrations. Their advantage often comes from the complete bundle.

Open-weight releases challenge that bundle by separating the model from its original operator. Customers can inspect the files, run them through another provider, fine-tune them, or deploy them within their own boundaries.

Hy4 preview strengthens that option because Tencent uses the Apache 2.0 license. The model's Hugging Face release identifies that license and exposes both the model files and supporting configuration.

Apache 2.0 grants broad rights to use, modify, and distribute licensed material. Organizations must still review the complete license, model documentation, applicable laws, and their intended deployment before making compliance decisions.

The weights also create a practical form of supplier choice. A team can test SiliconFlow first, evaluate another compatible host later, or investigate self-hosting. That path differs from a proprietary API whose core model remains available only through approved services.

Yet open weights do not automatically create an open operating environment. A hosted endpoint still requires trust in the provider handling prompts, outputs, logging, access controls, and service continuity.

Organizations evaluating SiliconFlow Hy4 preview need two separate reviews. One concerns the model and its behavior. The other concerns the managed platform processing company data.

This distinction becomes critical for coding agents. Such tools can receive source files, terminal output, credentials accidentally captured in logs, and internal architecture details. A strong model does not resolve governance questions around that information.

Compatibility with Claude Code, Codex, or Cursor should also be interpreted carefully. It means users can direct supported clients toward the model endpoint. It does not make Hy4 preview equivalent to the native models associated with those products.

Coding agents depend on more than raw generation. They require reliable tool selection, structured arguments, state tracking, error interpretation, and restraint. A model that writes strong isolated functions can still struggle across a long agent loop.

Tencent says Hy4 preview was built around coding, office analysis, game development, and scientific research. The company worked with internal specialists to shape training tasks around those domains.

Its model card reports a blind internal comparison involving 163 experts and 203 engineering tasks. Tencent says Hy4 preview achieved a 2.99 average rating in comparisons with GLM 5.3 and Kimi K3.

Against GLM 5.3, Tencent reports a 46.8 percent win rate, 12.8 percent tie rate, and 40.4 percent loss rate. Against Kimi K3, it reports 51.2 percent wins, 7.9 percent ties, and 40.9 percent losses.

Those numbers are informative, but they remain company-produced results. The evaluated tasks came from Tencent's internal environment, and the company defined the evaluation process. Independent reproduction is needed before treating the ranking as settled.

The comparisons also do not directly answer how Hy4 preview performs against every proprietary coding system. Different agents use different scaffolding, prompts, tool protocols, and retry policies. Model scores cannot isolate the entire product experience.

Hy4 preview has a stronger openness claim than models released under restrictive custom terms. Its weights are publicly available, and Tencent supplies deployment paths for vLLM and SGLang.

That openness pressures proprietary providers in a specific way. They must justify the value of closed access through better reliability, latency, safety, integrations, or overall results. Model quality alone becomes a less durable differentiator when alternatives can travel between hosts.

At the same time, Hy4 preview pressures smaller open-model developers. Its scale reflects resources available to a major technology company. Independent teams may struggle to train, distribute, and support systems of similar size.

SiliconFlow turns those competitive pressures into an accessible experiment. Customers do not need to accept the open-versus-closed debate in abstract terms. They can route controlled workloads to both approaches and measure results.

That experiment should focus on complete tasks. For coding, the meaningful unit is a tested change rather than a plausible snippet. For analysis, it is a defensible conclusion with traceable evidence.

For research, the useful outcome is not a fluent literature summary alone. The model must distinguish established findings, disputed claims, missing evidence, and unsupported inference.

Open weights offer options when the output disappoints. Teams can change system prompts, serving settings, quantization, fine-tuning, or providers. Proprietary services usually expose fewer layers of that stack.

More options also transfer responsibility. The customer must decide which configuration works, which risks are acceptable, and which changes invalidate earlier testing. Control brings operational work alongside flexibility.

What the Hy4 Preview Claims Still Do Not Establish

Hy4 preview arrives with unusually detailed specifications, but specifications and internal evaluations cannot establish production reliability.

Tencent openly labels this release a preview. Its documentation acknowledges known issues, including overly long reasoning on difficult tasks and a tendency to verify its own work too aggressively.

That disclosure matters because both behaviors affect agent economics and usability. Extended reasoning increases response time and token consumption. Excessive verification can also trap a tool-using agent in repetitive checks.

A coding assistant might repeatedly inspect files after producing a correct patch. An analysis agent might revisit settled evidence without improving its conclusion. These behaviors can reduce throughput even when the final answer is sound.

The one-million-token context claim needs similar pressure testing. Teams should not evaluate it only by confirming that the endpoint accepts a very large request. They should test whether the model recovers relevant evidence at different positions.

A useful evaluation would place decisive facts near the beginning, middle, and end of a controlled document set. Reviewers could then measure retrieval, contradiction handling, citation accuracy, and final reasoning.

Long-context tests should also include distracting material. Real repositories and document collections contain duplicates, abandoned plans, obsolete code, and unresolved comments. Clean benchmark prompts rarely capture that disorder.

The model's size creates another uncertainty. SiliconFlow must translate a complex architecture into acceptable service latency and availability. Public weights do not disclose the provider's exact hardware, batching policy, or capacity planning.

Performance can vary by prompt length, generated length, reasoning mode, and concurrent demand. A short code explanation may feel responsive while a repository-scale agent task behaves very differently.

Caching can improve repeated-context workloads by reusing processed prompt material. It helps when many requests share a stable prefix, such as a repository snapshot or policy collection. It helps less when each request contains unrelated material.

Developers should also distinguish model errors from integration errors. A malformed tool call might reflect the model, a schema translation layer, or the client. A failed agent run might involve permissions, sandbox behavior, or an incorrect command.

Controlled comparisons need identical tasks and acceptance criteria. Each model should receive equivalent context, tool permissions, and time budgets. Human reviewers should inspect both task completion and unintended changes.

Security deserves its own test track. Long-context systems can ingest untrusted documentation containing hidden instructions. An agent may follow those instructions unless the surrounding application separates data from commands effectively.

Open weights allow deeper security research, but access alone does not guarantee safety. A provider must still protect its service, while customers must constrain tools and validate model actions.

The release documentation does not establish how SiliconFlow handles retention, regional processing, incident response, or enterprise controls for this specific model. Buyers should examine current platform terms before sending sensitive information.

There is also no broad body of independent production evidence yet. Hy4 preview was released recently, and early community tests naturally favor interesting successes or failures. Neither kind of anecdote provides a representative reliability estimate.

Tencent's release statement presents the model as a major generational improvement. That framing comes from the developer and should remain attributed to the company.

Independent evaluations should examine common failure modes, not only leaderboard tasks. These include fabricated APIs, destructive code edits, incorrect spreadsheet formulas, unsupported scientific claims, and instruction drift over long sessions.

They should also measure recovery. Real agents encounter missing files, test failures, ambiguous requirements, and unavailable tools. A useful system recognizes those states and adjusts without inventing success.

Self-hosters face an additional verification gap. Quantized versions can behave differently from the original release, particularly on difficult reasoning or tool-calling tasks. Each compression format needs its own acceptance tests.

The FP8 release lowers the memory burden relative to higher-precision weights, but it remains a large deployment. Tencent's published recipe uses tensor parallelism across eight GPUs, which divides model computation among devices.

That recipe is evidence of technical availability, not universal practicality. Hardware models, interconnects, driver versions, and serving software all affect achievable throughput.

SiliconFlow absorbs much of that complexity for API users. In return, customers see less of the serving stack. They must infer quality through monitoring and contractual information rather than direct infrastructure control.

The sensible conclusion is neither automatic trust nor dismissal. Hy4 preview offers credible technical ingredients and verifiable open weights. Its hosted performance still requires independent, workload-specific evidence.

Three Signals Will Determine Whether Hy4 Preview Matters

Hy4 preview becomes consequential only if developers adopt it, independent tests support its claims, and serving remains dependable under demanding workloads.

The first signal is sustained use inside coding agents. Initial curiosity can produce high request volume, but repeat use shows whether the model completes work reliably enough to remain in routing policies.

Watch for public evaluations that measure repository-level completion, test passage, tool-call accuracy, and regression rates. Isolated coding prompts reveal less about an agent model than multi-step tasks with objective checks.

Teams can generate their own evidence quickly. Select a fixed group of maintenance issues, require passing tests, and record human correction time. Compare Hy4 preview with the incumbent under equal permissions.

If Hy4 completes more accepted tasks without increasing review effort, the open-weight route gains credibility. If teams repeatedly return to proprietary models, convenient API access will not overcome reliability gaps.

The second signal is independent long-context validation. A one-million-token limit attracts attention, but useful context depends on evidence retrieval and reasoning across the full sequence.

Evaluators should publish results at several input lengths rather than one maximum test. They should disclose prompt construction, document order, retrieval criteria, reasoning settings, and repeated-run variance.

Strong results across messy repositories and document collections would support Tencent's architecture choices. Sharp degradation as context grows would weaken the most distinctive part of the release.

The third signal is operational performance from SiliconFlow and other hosts. Developers need predictable latency, error rates, rate limits, and output behavior. A model that works only during light demand cannot anchor important workflows.

Provider competition can help here. Because Hy4 preview uses open weights, multiple services can optimize the same model. Customers can compare hosts without abandoning the underlying model entirely.

Self-hosting developments also matter. Improved kernels, lower-bit quantization, and better expert parallelism can reduce deployment barriers over time. Those improvements would extend the model beyond specialized inference providers.

However, aggressive compression must preserve behavior. Smaller files and lower memory use mean little if tool calling, reasoning, or instruction adherence deteriorates. Reproducible quality measurements should accompany efficiency claims.

Tencent's next model update will provide another important data point. The preview label implies unresolved training and post-training work. Changes to reasoning behavior could address the acknowledged tendency toward slow, excessive verification.

The company should also clarify benchmark methods and publish broader evaluation artifacts. More transparent tasks would let independent groups reproduce comparisons with GLM, Kimi, and proprietary systems.

For enterprise buyers, governance evidence will matter alongside model scores. They should watch for clearer documentation covering data handling, retention, regional availability, access controls, and service commitments.

Developers have a simpler immediate action. Place SiliconFlow Hy4 preview behind a model router and give it bounded tasks with measurable outcomes. Do not begin with unrestricted repository access or sensitive documents.

Start with code review, test generation, document synthesis, or research classification. Record latency, corrections, tool failures, and final acceptance. Repeat each task because one impressive result can mislead.

Then increase context gradually. Add repository history, specifications, issue discussions, and test output. Observe whether extra information improves decisions or merely lengthens reasoning.

This process tests the actual proposition behind SiliconFlow Hy4 preview. The proposition is not that 770 billion parameters automatically beat every closed model. It is that open weights can enter familiar workflows without a deployment project.

If independent results match Tencent's claims, proprietary providers face a stronger portability challenge. Customers will have another capable model that can move between managed services and private infrastructure.

If the results remain inconsistent, Hy4 preview will still matter as an engineering release. It will show how sparse attention, expert routing, and speculative decoding can support very large open models.

The decisive evidence will come from completed work, not parameter counts. Can the model finish a repository task, preserve constraints, cite the right evidence, and recover from failure?

SiliconFlow has made that question easier to test. Developers should now run controlled comparisons, publish reproducible findings, and decide whether open deployment rights translate into better everyday outcomes.