Tencent's Hunyuan 3.0 and the Rise of Selectable Inference Modes

Tencent open-sourced the third generation of its Hunyuan family on 6 July 2026: a mixture-of-experts model with roughly 295 billion total parameters and about 21 billion active, a 256K-token context, and three selectable inference modes.

The parameter count is the headline and the inference modes are the interesting part. Across the industry in 2026, the most practically useful feature is not a capability jump but a control: letting the user decide how much deliberation a request gets.

The Problem Selectable Modes Solve

Reasoning models were a genuine advance. Training a model to work through a problem before answering unlocked whole categories of task that pattern-matching could not reach: multi-step debugging, complex planning, mathematical work.

Then labs made deliberation the default, and everyone discovered the cost. Deliberation consumes tokens, which costs money, and it consumes time, which costs patience. On a task with hidden depth that is an excellent trade. On “change this email from blunt to formal” it is pure overhead, and you sit watching a spinner while a model carefully considers a sentence that needed no consideration.

Selectable modes fix the mismatch. Hunyuan’s three modes, Anthropic’s five-level effort setting on Opus 5, and similar controls across the field all address the same thing: the user knows whether the task is hard, and the model does not.

Match The Mode To The Task

A rule that generalizes across every model exposing this control.

Fast or direct mode for transformations: rewriting, tone changes, reformatting, short summarization, extraction. The input contains everything needed and there is nothing to derive. Deliberation adds latency and occasionally adds unwanted commentary.

Standard mode for ordinary generation: drafting a message from a brief, writing a summary that requires judgment about what matters.

Deep or high-effort mode for problems with a right answer several steps away: reconciling a document against itself, analysis, planning with interacting constraints, anything where being wrong is expensive.

Most people never touch the setting, use whatever the default is for everything, and form an impression of the model based on a mode mismatched to their task. If a model feels slow and chatty for rewriting, check the mode before blaming the model.

The Local Version Of The Same Problem

This is not only a cloud consideration. It bites hardest on local models, where you feel every extra token.

Several open-weights families ship hybrid models that can operate in a deliberating or a direct mode, with the selection made through the chat template rather than an API parameter. Qwen3’s hybrid models are the widely used example: the template prefills an empty thinking block to signal non-thinking mode, and if the harness does not do that, the model deliberates by default.

The symptom is distinctive: a local rewrite that is slow and returns a monologue about the rewrite rather than the rewrite. People conclude their hardware is inadequate or the model is bad, when the actual problem is a template detail.

Wrivio handles this for hybrid models, which is why a local rewrite returns prose. If you are wiring a model up yourself, it is the first thing to check. There is more in thinking models versus instant models for rewriting.

Open Weights At 295B: The Usual Reality Check

Hunyuan 3.0 at 295 billion total parameters with 21 billion active is genuinely open and genuinely not runnable at home. Memory is set by total parameters, not active ones, so you need capacity for all 295 billion regardless of how few fire per token. That is multi-GPU server territory.

So this is another entry in the growing category of models that are open in the sense that anyone may download, inspect, fine-tune, and serve them, and closed in the practical sense that most people will reach them through somebody’s API. Worth being clear about, since “open source model” increasingly covers two situations with nothing in common. We ran the arithmetic in can you run a trillion-parameter model locally.

The models you can actually run stay in the 1B to 8B range on a laptop, or up to roughly 30B with a 24GB GPU. That is where the writing tools live.

Why The Selectable-Mode Trend Favors Local Tools

A slightly counterintuitive consequence.

As the industry adds effort controls, it is implicitly admitting that most requests do not need the frontier’s full deliberation. That admission is the same premise local small models are built on: many valuable tasks are constrained enough that a modest model with a precise instruction handles them completely.

If a frontier lab’s own recommendation for a simple transformation is “use the fast mode,” you are close to the argument for “use a small model,” and the small model has the additional property of running on your machine with no transmission at all.

The task that proves it is rewriting. The facts are in your input. The model changes register and structure. A 1.7B model with a six-clause instruction does that well, in a second or two, offline. See why small models beat big ones for rewriting.

Constrain, Then Choose The Mode

Whichever model and mode you use, the instruction does more work than the setting:

Rewrite this as a professional work email. Corporate register, complete sentences, no contractions. Lead with the ask and the deadline. Keep every name, date, figure, and commitment exactly as written. Do not add enthusiasm or context that is not in the original. Keep the result no longer than the input. Return only the rewritten text, with no preamble or explanation.

That final clause is what stops a deliberating model from narrating. Wrivio applies constraints of this kind at the template level so they hold across every Context, and stores the situation-specific part per Context so you write it once.

Common Questions

Which mode should I use for email rewriting?

The fastest one. There is nothing to reason about in a register change, and deliberation costs latency you will feel on a task you do a dozen times a day.

Does fast mode produce worse writing?

Rarely, for transformations. It produces worse results on problems that genuinely need steps, which rewriting is not.

How do I tell if my local model is deliberating unnecessarily?

It will be slower than expected and may emit reasoning text before or instead of the answer. Check whether the model is a hybrid and whether your tooling sets the non-thinking signal in the chat template.

Is a 295B open model useful to me?

Only through a hosted provider, and at that point the privacy analysis is the same as any cloud service. For confidential text, a small local model is the configuration that actually changes the answer.

Download Wrivio for Windows to run rewrites in direct mode on a local model, with the template details already handled.