Xing 4.0 29B-A4B vs Granite 4.2 30B: Dense Reads Everything, Sparse Reads a Ninth

Here is the entire architectural argument in one sentence. G​ranite 4.2 30B, I​BM's dense reasoning model published under Apache 2.0 on 25 August 2026, reads all thirty billion of its parameters to produce every single token. Xing 4.0 29B-A4B, China Telecom's sparse mixture-of-experts model whose weights went up on 16 September 2026 and which became callable in mid-October, reads roughly four billion of its twenty-nine. Both are Apache-2.0, both sit in the same weight class, both target agentic work, and they cost you completely different things to run: G​ranite costs compute on every token, Xing costs memory to hold experts you are not using on this token and a serving stack that knows how to route around them. Everything below follows from that.

What each artefact actually is

It is worth separating them from the label they share. "30B" tells you the size of a file, not the shape of a workload.

• G​ranite 4.2 30B — I​BM's flagship in the G​ranite 4.2 family, built on G​ranite-4.1-30B-Base. A decoder-only dense reasoning transformer, 30B parameters (the repository lists 29B in BF16 tensors), grouped-query attention with 32 attention heads against 8 key-value heads, RoPE at θ = 10,000,000, SwiGLU MLP with a hidden size of 32,768, untied input and output embeddings, RMSNorm at ε = 1e-5. Twelve tested languages. Apache 2.0.

• Xing 4.0 29B-A4B — TeleAI's successor to the TeleChat line. 40 layers, hidden size 3,584, dense FFN intermediate 9,216 against an expert intermediate of 1,024, 64 routed experts with 4 active per token plus one shared expert always on, MLA compressed-key-value attention instead of GQA, and MTP speculative decoding trained into the checkpoint. Effectively one tested language on the card. Apache 2.0.

• Context — G​ranite 4.2 30B natively supports 128K with a documented long-context extension to 512K and a configuration sequence length of 131,072. Xing 4.0 carries 256K natively, claimed extensible to 512K. Xing's default window is twice as wide; G​ranite's extension path is the better documented of the two.

• Formats published — G​ranite 4.2 30B ships in BF16 plus FP8, MXFP4 and NVFP4 quantisations, with GGUF builds from I​BM and from the community. Xing 4.0 ships in BF16 safetensors plus FP8, w8a8 and GGUF. Both are unusually well provisioned here, and both are a real advantage over the many open releases that publish one bfloat16 shard and leave the quantisation to volunteers.

• Availability — G​ranite 4.2 30B has no token-priced endpoint in our catalogue; you run it, or you reach it through I​BM's own platform and other third-party serving platforms. Xing 4.0 gained a metered commercial endpoint in mid-October with a free promotional tier, and is also absent from our catalogue.

The memory-versus-compute trade, stated honestly

Sparsity is not a discount on the whole machine; it is a discount on one axis and a surcharge on the other. G​ranite 4.2 30B needs roughly the memory of a 30B dense model in bfloat16 and computes across all of it per token, so its throughput per unit of hardware is predictable and its behaviour under batching is straightforward. Xing 4.0 needs to hold the full 29B resident — every expert sits in memory whether or not this token touches it — but only moves 4B worth of weights per token through the arithmetic, which is why a 4-bit quantisation of it is claimed to fit in around 15GB of VRAM and why its aggregate throughput at high concurrency is a different shape entirely.

That claim is worth checking before you buy a card around it: the repository reports 31B in the full-precision tensors, and a 4-bit build of a 29B total model landing at 15GB implies aggressive quantisation of the expert weights. Look at the actual GGUF file size rather than the collection blurb.

The second, quieter difference is maturity of the serving path. G​ranite 4.2 30B is a standard dense transformer, which means every inference stack supports it more or less by default. Xing 4.0 needs custom kernels for its manifold-constrained hyper-connection residual streams and its MLA attention — SGLang carries a dedicated split-K kernel for the four-stream layout, vLLM has the architecture, and that is the state of things. A bespoke attention-plus-residual design is the price of the architecture, and it is not a one-time cost if you plan to fine-tune, quantise, or run unusual batch shapes.

Where the published numbers actually disagree

Both vendors publish their own tables, both are internally consistent, and neither has been independently reproduced by a third party on identical harnesses. Compare them as claims, not measurements.

• SWE-bench Verified — Xing 4.0 75.00 vs G​ranite 4.2 30B 57.

• SWE-bench Multilingual — Xing 4.0 66.00 vs G​ranite 4.2 30B 41.89.

• Terminal-Bench 2.1 — Xing 4.0 57.50 vs G​ranite 4.2 30B 29.24.

• Agentic tool use — Xing 4.0 Claw-Eval 76.55 and Tau3-Bench 64.63; G​ranite 4.2 30B τ³-bench 62.00 and BFCL v4 61.39.

• Instruction following — Xing 4.0 IFBench 69.67 vs G​ranite 4.2 30B IFBench 77.17.

• Math and general reasoning — G​ranite 4.2 30B AIME25 89.17, HMMT Feb25 89.17, GPQA 66.41, MMLU-Pro 77.60, LiveCodeBench v6 75.77. Xing 4.0's card reports none of these, so the columns go blank rather than turning into a win.

• Long context — G​ranite 4.2 30B publishes RULER at 64K (89.96) and 128K (81.38). Xing 4.0 publishes AA.LCR at 61.00 and nothing else in the long-context family. G​ranite wins the only row where both numbers exist, and it is a meaningful win: RULER at 128K is a much harder test than a retrieval-average score.

Read the shape rather than the totals. G​ranite reads as a broad, well-measured generalist with an unusually honest evaluation table — 20 rows across coding, math, tool use, document tasks and long context, all with the harness stated as a NeMo Evaluator SDK framework. Xing 4.0 reads as a narrow specialist: enormous margins on software-engineering and terminal agent benchmarks, a loss on instruction following, and silence everywhere else. A model with no GPQA number is not necessarily bad at GPQA. It is a model whose vendor chose to publish nine rows.

Two honest asymmetries

G​ranite 4.2 30B has been public for seven weeks and carries the scrutiny that implies, including independent quantisations, detailed third-party write-ups and I​BM's own published comparison values for its 8B and 3B siblings on every single row of the table. Xing 4.0 has been public for a month, has 53,000 repository downloads, has no independent evaluation, and benchmarks itself against re-runs of rival models the vendor performed in its own harness. An earlier comparison in this series already covers how that comparison table treats Gemma 4; the structural point holds for any column in it.

The asymmetry runs the other way on one axis. G​ranite 4.2 30B is a reasoning model with a dense compute profile, which means it is slow per token in a way that is inherent to the design and cannot be routed around. Xing 4.0's whole argument is that you get a 29B model's memory footprint with a 4B model's arithmetic. If that argument holds on real workloads, it is a genuinely better deal for high-volume agent traffic — and it is exactly the argument that a vendor's own SWE-bench row cannot settle.

What it costs, and where a router fits

Neither model is in OrcaRouter's catalogue, so we are not a route to either, and this piece will not suggest otherwise. The relevant arithmetic is still worth doing. G​ranite 4.2 30B costs a card and nothing else, forever, with the caveat that its dense compute means the card you need is a bigger one. Xing 4.0 costs a GPU and a serving-integration weekend up front, or a metered free-tier evaluation right now — and the free tier is the cheapest way to find out whether the agentic claims survive your own repository rather than a terminus-2 harness run by the model's author.

Where a router earns its keep with two models we do not host is at the perimeter. You do not replace the model your production path already knows; you run the challenger beside it on a slice of traffic, under a stated rule, with automatic failover so that a bad answer or an upstream stall never reaches a user. OrcaRouter is one API in front of 200-plus hosted models at 0% markup — provider list price passed through with nothing added — and the routing DSL is how the slice gets defined. When the evaluation ends, the rule changes and the incumbent takes the traffic back.

If your evaluation budget is one model, take G​ranite 4.2 30B when the work is broad — long-document reasoning, multilingual generation, instruction-following-heavy pipelines, anything where you want a published number for the task you actually run. Take Xing 4.0 29B-A4B when the work is narrow and agentic, you can measure it yourself, and the throughput-per-card argument is the thing you are buying. The one choice that is clearly wrong is picking Xing 4.0 on the strength of 75-versus-57 alone: those two numbers were produced by different laboratories on different harnesses, and the only thing they reliably establish is which vendor published a SWE-bench row.

What would settle it

One independent evaluation of Xing 4.0 on the same harness G​ranite was measured on, with the same scaffolding, would collapse most of the uncertainty in this piece in a single afternoon's work by someone with a spare GPU. Until that exists, the dense model is the one whose numbers you can act on and the sparse model is the one whose numbers you have to check. Both statements will be equally obsolete the moment the second one stops being true.

None of that is hypothetical: the documented AI failures and agent incidents behind releases like this one are collected in the OrcaRouter AI Incident Archive, where each entry carries its own sources, severity, confidence grade and disputed flag.