Uncensored Hy3 Model API

Most "which model should I use" arguments are about the ceiling: which one writes the best code, solves the hardest math, wins the longest agent run. Structured pipelines do not work like that. A job extracting fields from a hundred thousand documents a day does not need a model that is brilliant once — it needs one that is correct in the same shape every time, and that never returns a paragraph where a JSON object belongs. That is the property Hy3-W8A16 is here for.

01What Hy3 is, and where it comes from

Hy3 is an open-weight reasoning and agentic model from Tencent's Hunyuan team, released in full on July 6, 2026 under a permissive license, with weights published on Hugging Face. It continues the lineage of Tencent's earlier Hunyuan-Large Mixture-of-Experts work. Architecturally it is a sparse MoE: 295 billion total parameters, of which roughly 21 billion activate per token via top-8 routing across 192 experts, on an 80-layer transformer with grouped-query attention, plus a separate 3.8B multi-token-prediction layer for speculative decoding. Native context is 256K — exactly the 262,144 tokens we expose, not a truncation of something larger or a rope-stretched extension of something smaller.

That sparsity ratio is the important number for anyone paying per token: Hy3 carries the knowledge of a 295B model while doing roughly the arithmetic of a 21B one per forward pass. It is also why we can afford to serve it at 8 bits rather than compressing it harder — an 8-bit build of a model this sparse still fits and still runs fast on our own GPU cluster.

What Tencent reports it is good at

Tencent's published evaluation tables put Hy3's strengths squarely in agentic search, tool orchestration, and long-context retrieval rather than in raw coding. Their reported figures:

We show the weak bars on purpose. Hy3 trails GLM-5.2 on coding in Tencent's own comparison — 78.0 against 84.2 on SWE-bench Verified, 28.0 against 46.2 on DeepSWE. If your workload is autonomous multi-file software engineering, read the rest of the model research index first. If it is reading text and emitting structure, the profile is close to ideal.

The figure that matters most for pipeline work is a reliability one: Tencent reports Hy3's hallucination rate at 5.4%, down from 12.5% in the prior generation, with commonsense errors falling from 25.4% to 12.7%. Their stated training principle — answer when there is evidence, say plainly when there is none — is exactly the disposition you want in an extraction model that would otherwise invent a plausible value for a field the source never mentions.

All figures in this section are Tencent-reported from their own test runs; independent third-party verification was still pending at the time of writing. Treat them as directional, not settled.

02What W8A16 means, and why it matters for structured output

Every model on the gateway carries a quantization suffix. It is not decoration — it tells you how far the served weights sit from the checkpoint the lab released.

Tier	What it does	Fidelity
3BIT-REAP	3-bit weights plus REAP, an expert-pruning method that drops rarely-routed MoE experts before quantizing	Most compressed
W4A16-AUTOROUND-REAP	4-bit weights / 16-bit activations via AutoRound — learned rounding that recovers accuracy over naive round-to-nearest — plus REAP pruning	Middle
W8A16	8-bit weights / 16-bit activations. No pruning, no learned-rounding repair — the weights simply carried at twice the precision	Highest

Where quantization drift actually hurts

REAP and AutoRound recover most of what naive compression loses — but "most" is doing work in that sentence, and the residue does not land evenly. Low-bit quantization degrades the tails: the low-probability, high-specificity decisions. In prose that is nearly invisible; a different adjective is still a fine sentence. In structured output it is the whole game, because a schema is a long chain of low-probability decisions that must each be exactly right:

• Token-level syntax. A closing brace, a comma, a quote character. Each is one token, and one wrong token invalidates the entire response.
• Enum discipline. Your schema says "status" is one of "open" | "closed" | "pending"; a drifted model returns "Open" or "pending review" — semantically close, and valid as neither.
• Type discipline. A number field comes back as "1,240", a boolean as "yes". Both parse as strings and fail the schema.
• Long-tail literals. Rare proper nouns, part numbers, chemical names, non-Latin scripts, precise dates — exactly the low-probability region low-bit weights blur.

None of this makes 4-bit or 3-bit models bad; for conversational work the fidelity difference is often not worth the price difference. But when the consumer of the output is a validator rather than a human, precision at the tails converts directly into parse rate — and parse rate into retry budget and p99 latency. W8A16 is the tier where you stop paying that tax.

03Structured output: json_schema and response_format

Hy3 supports both halves of the structured-output surface — worth stating explicitly, because that is not universal across the catalog:

Model	response_format	json_schema
Hy3 · W8A16	Yes	Yes
MiMo-V2.5-Pro · W8A16	Yes	Yes
inkling · W4A16-AUTOROUND-REAP	Yes	No
Laguna-S-2.1 · W4A16-AUTOROUND-REAP	No	No

The difference between the two mechanisms matters more than people assume. response_format: {"type": "json_object"} asks for valid JSON and nothing more — the model picks the shape, so two calls can return {"name": ...} and {"full_name": ...} and both are correct. json_schema supplies the shape up front: named fields, types, enums, required lists, nesting. That is a contract you can write code against.

A minimal call on the OpenAI-compatible dialect:

POST /v1/chat/completions

{
  "model": "Hy3-W8A16",
  "messages": [
    {"role": "system", "content": "Extract fields from the incident report. Use null for anything not stated."},
    {"role": "user", "content": "<report text>"}
  ],
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "incident",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "severity":  {"type": "string", "enum": ["low","medium","high","critical"]},
          "component": {"type": "string"},
          "occurred_at": {"type": ["string","null"], "description": "ISO-8601"},
          "affected_users": {"type": ["integer","null"]},
          "indicators": {
            "type": "array",
            "items": {"type": "object", "properties": {
              "kind":  {"type": "string", "enum": ["ip","domain","hash","cve"]},
              "value": {"type": "string"}
            }, "required": ["kind","value"]}
          }
        },
        "required": ["severity","component","occurred_at","affected_users","indicators"]
      }
    }
  }
}

Practical notes

• Make every field required and allow null. Optional fields invite silent drops; a required nullable field forces an explicit "not present," which is information you can act on.
• Enums beat free strings. Wherever you can close the value set, close it — the highest-leverage change to a schema's real-world pass rate.
• Stay under the 16,384-token output ceiling. An unbounded array will truncate mid-object. Cap array lengths, or shard the input.
• Keep the system message. The schema constrains shape; the prompt still governs semantics — what counts as "critical," which date wins when two appear, whether to normalize units.
• Validate anyway. Schema support raises the pass rate; it does not replace a validator and a dead-letter queue.

04Why "uncensored" is a reliability property, not just a content one

Hy3 on the gateway has no refusal layer and no output filtering. The usual framing is about content: you can process security research, malware analysis, exploit write-ups, medical and legal corpora, adult material, harm-reduction documentation or hostile-user transcripts without the model deciding on your behalf that it would rather not.

There is a second, more mechanical reason it matters. A refusal is a schema violation. A filtered model that declines does not return your object with an "unavailable" flag — it returns prose. "I'm not able to help with that request." That string is not an incident object; it fails your validator and lands in the dead-letter queue beside genuine parse errors, where you now have to separate policy refusals from real malformations.

Worse, refusals correlate with content rather than distributing randomly. If 4% of your corpus is security incident reports and the model declines most of them, you have not lost 4% of throughput evenly — you have lost one category, and the dashboard built on that data quietly under-reports the exact thing it exists to surface. Category-shaped holes cost more than uniform noise because nothing alerts on them. Remove the refusal path and what remains — malformations, truncations, ambiguous text — is uncorrelated with topic, and therefore measurable.

05Context, output ceiling, and how to budget them

Every model on the gateway shares the same limits:

Context is a shared budget: prompt plus output must fit inside 262,144 together, so the practical input ceiling in one call is about 245,000 tokens, very roughly 180,000 English words. For structured work the 16,384-token output cap is the harder limit and the one that surprises people — a schema emitting one object per record hits it long before the window fills. Two patterns work against that:

• Wide input, narrow output. Push a whole contract, filing or log window into context and ask for one compact object. Input tokens cost a quarter of output tokens, so the pricing rewards reading a lot and writing a little.
• Chunk on record boundaries, not byte counts. Split where the model can see the seam. A record cut mid-sentence produces a confidently wrong object rather than an obvious failure.

Hy3's reported long-context retrieval strength — 73.4 on AA-LCR, and a jump from 42.9% to 75.1% on MRCR long-dialogue recall — is exactly the capability the first pattern depends on, and a different skill from writing well.

06Floor pricing, and the arithmetic of a real pipeline

Hy3 sits at $0.50 per million input tokens and $2.00 per million output tokens — the catalog floor, shared with MiMo-V2.5, MiMo-V2.5-Pro, DeepSeek-V4-Flash-0731 and MiniMax-M3. Worked through representative loads:

Workload	Input / call	Output / call	Cost / call	Per 1M calls
Field extraction	1,200	300	$0.0012	$1,200
Document classification	3,000	120	$0.0018	$1,800
Long-doc summarize to schema	40,000	900	$0.0218	$21,800
Full-window analysis	240,000	2,000	$0.1240	$124,000

The number that changes decisions is not the headline rate but the effective rate after retries. If two models cost the same and one fails validation on 6% of calls where the other fails on 1.5%, the high-drift model runs about 4.5% more calls — survivable. The damage is on the tail: retried calls take twice as long, so p99 latency roughly doubles for a visible slice of traffic, and whatever fails twice becomes manual work. At a million calls a day that is thousands of records someone has to read.

Hence the case for the 8-bit tier at floor price: you are not paying a premium for fidelity here, so the retry arithmetic is free money. If a 3-bit model were cheaper there would be a real trade to weigh — Hy3 costs the same as the cheapest thing in the catalog.

07Three API dialects, one model

Hy3 is reachable on all three gateway dialects with streaming on each. Same model, same weights, same limits — pick whichever matches the SDK you already have.

Endpoint	Dialect	Use when
/v1/chat/completions	OpenAI	You have an OpenAI SDK, LangChain or LlamaIndex. Point the base URL here, change the model id.
/v1/messages	Anthropic	You are on the Anthropic SDK and want content blocks without a translation layer.
/v1/responses	Responses	You want the newer request shape with typed output and server-side state.

Hy3 also supports tool calling and reasoning, including reasoning_effort. For extraction work the useful move is usually to turn reasoning down: on a well-specified schema over clean text, thinking tokens are output tokens you pay for and latency you wait through, for a marginal gain. Spend the effort budget on genuinely ambiguous input instead.

Full request and response reference, parameter lists, streaming semantics and an interactive playground live in the API documentation.

08Choosing among the three W8A16 models

Three models sit on the highest-fidelity tier, all at floor price. The choice is mostly modality:

Model	Vision	json_schema	Price in / out	Pick it for
Hy3 · W8A16	No	Yes	$0.50 / $2.00	Text-only structured pipelines, tool orchestration, long-context retrieval
MiMo-V2.5-Pro · W8A16	No	Yes	$0.50 / $2.00	Text-only work where you want the Pro tuning of the MiMo line
MiMo-V2.5 · W8A16	Yes	Yes	$0.50 / $2.00	Anything with images — scanned documents, screenshots, photos

If any part of your input is an image the decision is made for you: Hy3 is text-only — send scanned PDFs, screenshots and photographs to MiMo-V2.5. Where the input is genuinely text, Hy3's profile of agentic tool use, long-context recall and low reported hallucination maps most directly onto pipeline work. Since all three cost the same, run your schema against two of them on a few hundred real records and compare parse rates; that settles it better than any table, including this one.

09Where Hy3 earns its place

• High-volume field extraction. Contracts, filings, incident reports, transcripts, clinical notes, court records — anywhere a typed object per document is the deliverable and volume makes retries expensive.
• Classification and routing at scale. Closed enum outputs, where the model's whole value is never inventing a nineteenth category.
• Security and threat-intel corpora. Malware write-ups, exploit disclosures and phishing samples — the material that trips filtered models into refusal, and where a category-shaped hole defeats the purpose.
• Tool-calling agents that must not stall. 8-bit argument fidelity means the JSON handed to your functions parses; a mangled tool call is a stalled agent, not a slightly worse answer.
• Long-document analysis into structure. Whole filing in, one compact object out.
• Content moderation and policy research. Labeling material a filtered model refuses to read is a standing trust-and-safety problem; an unfiltered model with a strict schema solves it directly.

And where it does not: anything with images (use MiMo-V2.5), and autonomous multi-file software engineering, where Tencent's own tables put Hy3 behind GLM-5.2 on SWE-bench Verified and well behind on DeepSWE.

Benchmark figures are Tencent-reported, including the competitor numbers; independent verification was pending at the time of writing. Cost figures are computed from our published $0.50 / $2.00 rates. No number on this page is a Shannon-run benchmark or an estimate.

10Frequently asked questions

---

Sources: Tencent Hunyuan model cards · Hy3 repository · Hunyuan-Large: An Open-Source MoE Model (arXiv 2411.02265) · VentureBeat coverage of the Hy3 release. Foundation benchmarks are Tencent-reported and provisional pending independent verification. Shannon AI is operated by Shannon Lab LLC, New Mexico, USA.