What is Tencent Hy3? A guide to the 295B MoE model's API and pricing

What is Tencent Hy3?

Tencent Hy3 is a 295-billion-parameter Mixture-of-Experts (MoE) model. The defining property of an MoE architecture is that not all parameters run for every token. In Hy3, roughly 21 billion parameters activate per token. The practical consequence is that a 295B model can be served at an inference cost closer to that of a 21B model.

The model is positioned for coding agents, long-document analysis, multi-turn dialogue and multi-step tool workflows. It accepts text only and produces text only; there is no image, audio or video input. If you need vision, look at the multimodal rows in the catalog instead.

• Total parameters: 295 billion; active per token: roughly 21 billion.
• Context window: 192K tokens (196,608) — not the advertised 256K, see below.
• Tool calling, JSON schema output and prompt caching are supported.
• Thinking is off by default and enabled per request.

Advertised at 256K, published at 192K: why the gap matters

Hy3 is publicly announced with a 256K context window. In measurement, the largest input a single request accepts is 196,608 tokens, which is 192K. Above that limit the provider does not return an error — it silently drops the oldest part of the prompt and answers from what remains. No field reports the loss.

This is the most dangerous failure class in long-document work: the system appears to work, HTTP 200 comes back, the answer reads fluently, but the model's response rests on a fragment of the document you sent rather than all of it. In contract review or regulatory comparison, that is an accuracy loss that is hard to notice.

LLMTR therefore publishes this model's context length as 192K in the catalog. Keep long documents under that limit, or chunk them and process each chunk in its own request.

Thinking modes: off, shallow and deep

Thinking is off by default in Hy3. Call the model identifier as it is and the model answers directly. To turn thinking on you append a suffix to the model identifier: low means shallow, high means deep.

There are no intermediate levels. The minimal, medium and xhigh tiers found on some models do not exist here, because in measurement they produced no distinct behaviour between low and high. Three states are real: off, shallow, deep.

When thinking is on, the reasoning chain does not blend into the answer; it comes back separately in reasoning_content. For billing, though, the point that matters is this: those tokens are counted inside completion_tokens and billed at the output rate. A short question run with deep thinking can therefore be markedly more expensive than the same question with thinking off. Size max_tokens accordingly.

The same question in three thinking states: nothing changes but the suffix

import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmtr.com/v1",
    api_key=os.environ["LLMTR_API_KEY"],
)

QUESTION = "What is this function's time complexity, and why?"

# Off:     direct answer, no thinking tokens spent.
# Shallow: :low suffix
# Deep:    :high suffix
for model_id in ["tencent/hy3", "tencent/hy3:low", "tencent/hy3:high"]:
    response = client.chat.completions.create(
        model=model_id,
        messages=[{"role": "user", "content": QUESTION}],
        max_tokens=2048,
    )
    message = response.choices[0].message
    # The reasoning chain returns separately; empty when thinking is off.
    reasoning = getattr(message, "reasoning_content", None)
    print(model_id, "->", response.usage.completion_tokens, "output tokens")
    if reasoning:
        print("  reasoning length:", len(reasoning))

Tool calling and JSON output: two constraints worth knowing

Hy3 supports tool and function calling natively, but it behaves differently from what you may expect in two places, and both can bite in production.

The first is tool_choice. The values auto and required work: the model calls a tool when it judges one appropriate, or is forced to call some tool. Forcing one specific function by name, however, is not reliable on this provider — the model may call the tool that fits the prompt rather than the one you named. Do not use a named choice as a constraint; your flow has to tolerate the wrong tool being called.

The second is JSON output. Schema-enforced output through json_schema is supported and works. The json_object format is not. The json_object pattern common in OpenAI-compatible clients cannot be used with Hy3; you have to express your schema as json_schema. That is in fact the stronger guarantee, because the output is not merely valid JSON but JSON conforming to the schema you defined.

• tool_choice auto — the model calls a tool when appropriate. Works.
• tool_choice required — the model must call some tool. Works.
• Forcing a named function — not reliable, do not use as a constraint.
• response_format json_schema — supported, enforces the schema.
• response_format json_object — not supported.

Pricing and prompt caching: where the cost actually falls

Hy3 costs USD 0.14 per million input tokens and USD 0.58 per million output tokens. When a repeated prefix is served from the prompt cache, the input side drops to USD 0.035 — a quarter of standard input. That is a meaningful difference for flows that send the same system prompt or the same document header over and over.

For the cache to work, requests have to share a common prefix. Put the variable part, the user's question, last, and the fixed part, the system prompt, tool definitions and reference document, first. Build it the other way around and the cache never holds, so every request bills at full price.

LLMTR does not mark up model prices; the platform margin applies only to credit top-ups. The figures above are the provider's own rate card.

Your first request through LLMTR

Reaching Hy3 through LLMTR works with any OpenAI-compatible client. Set the base URL to https://llmtr.com/v1 and pass tencent/hy3 as the model identifier; the rest of your client code stays as it is.

The model runs on third-party infrastructure outside Turkey. Prompts and completions may be logged by the provider; it is not an LLMTR model hosted in Turkey. For prompts containing personal data, consider the Turkey-hosted rows in the catalog instead.

A single request with curl: the plainest form, without tool calling or schema enforcement

curl https://llmtr.com/v1/chat/completions \
  -H "Authorization: Bearer $LLMTR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tencent/hy3",
    "messages": [
      {"role": "system", "content": "Answer briefly and technically."},
      {"role": "user", "content": "What does active parameter mean in an MoE architecture?"}
    ],
    "max_tokens": 512
  }'

Frequently asked questions

Is Tencent Hy3's context window 256K or 192K?

The model is advertised at 256K, but a single request accepts at most 196,608 tokens (192K) of input. Beyond that the provider silently drops the oldest part of the prompt without reporting it. LLMTR therefore publishes 192K; keep long documents under that limit.

Does Hy3 accept images?

No. Hy3 accepts text only and produces text only. There is no image, audio or video input. If you need vision, look at the multimodal models in the catalog.

How do I turn on thinking in Hy3?

By appending a suffix to the model identifier: tencent/hy3:low for shallow and tencent/hy3:high for deep thinking. Without a suffix, thinking is off. Thinking tokens count inside completion_tokens and bill at the output rate.

Why does the json_object format not work?

Hy3 does not support the json_object format; only json_schema is supported. Express your schema as json_schema. That is the stronger guarantee, because the output is not just valid JSON but conforms to the schema you defined.

Related posts

• Nemotron 3 Ultra 550B A55B 262K: NVIDIA's largest open-weight MoE model
• Choosing an LLM API for coding agents: Claude, Codex, Gemini CLI
• Comparing Turkish LLM models: quality, pricing, and API access

• Tencent Hy3 model sayfası
• Model catalog
• Chat Completions guide
• Pricing