Hy-Memory-30B-A3B vs Granite 4.2 30B: A Memory Writer and a Reasoner Are Not the Same Purchase

Hy-Memory-30B-A3B and Granite 4.2 30B are both around 30 billion parameters, both open-weight, both Apache 2.0, both released within seven weeks of each other — and they are not substitutes for one another in any sense a procurement spreadsheet would recognise. Hy-Memory-30B-A3B, open-sourced by the Hunyuan team on October 15, 2026, does one thing: it executes the write path inside a long-term memory framework, deciding what an agent keeps and how new evidence overwrites it. Granite 4.2 30B, published by IBM on Hugging Face on August 25, 2026, is a dense generalist reasoning model with selectable thinking modes, tool calling and a 128K context it can stretch to 512K. One is a component. One is an assistant. That gap between what a scoreboard measures and what a deployment meets is the reason the record matters: the documented AI failures and agent incidents around models in this class are collected in the OrcaRouter AI Incident Archive where each entry carries its own sources, severity, confidence grade and disputed flag.

The tempting comparison — line up their benchmark tables and see who wins — is the wrong comparison, and it is wrong in a way that would cost you money. They were not evaluated on the same tasks, they are not deployed the same way, and one of them cannot be downloaded in a form most people can run. What follows is the comparison that actually decides anything: what each is for, what each costs you in hardware, and whether you need one, the other, or both.

Start with the axis that separates them

Granite 4.2 30B is dense, which means every one of its parameters is read for every token it generates. It has three reasoning modes — full thinking, low-effort, and none — selectable per request, and it was post-trained with agentic reinforcement learning aimed at terminals, code execution and web search inside a sandbox. IBM's card claims 57.00 on SWE-Bench Verified, 29.24 on Terminal-Bench 2.1, 89.17 on AIME 2025 and 77.60 on MMLU-Pro. Those are vendor-reported and not independently reproduced, and the model is two months old — old enough that a lack of independent scores is mildly notable, not damning.

Hy-Memory-30B-A3B is sparse, which means it holds 30 billion parameters but reads about 3 billion per token, and it was trained for a single task. The Hy-Memory card describes it as replacing the general-purpose LLM inside Mem0, MemOS and Hy-Memory — deciding what to retain, how to represent it precisely, and how new evidence updates a persistent memory bank. It was then tested on EverMemOS, a framework held out of training entirely, which is the closest thing in either release to a real generalisation test. Its headline claim: a 55.49 macro average across four harnesses against 54.62 for Claude Opus 5. Also vendor-reported, also unreproduced, and — unlike Granite's numbers — evaluated on a fixed 20% subsample of each benchmark rather than the full set.

So the scores do not compare. Granite's 57.00 on SWE-Bench Verified and Hy-Memory's 55.49 macro average are numbers from different sports, and putting them in one column would be a lie of arithmetic.

It is also worth noting where these numbers come from. The Hy-Memory figures sit in a technical report, arXiv 2610.22196, submitted the same day the weights appeared — the primary source is public and readable, which is more than many release-day tables come with. the other side's sit on a model card. Both are the vendor marking its own homework, and neither has been through anyone else's harness.

The specs, dimension by dimension

• Parameters — Hy-Memory-30B-A3B 30B total / ~3B active MoE vs Granite 4.2 30B roughly 29B dense, all parameters active on every token.

• Layer shape — 48 layers for Hy-Memory-30B-A3B, one dense feed-forward block and 47 sparse MoE blocks, 128 experts per block at top-8 routing plus a shared expert vs Granite 4.2 30B's standard dense decoder-only transformer with GQA, 32 attention heads and 8 key-value heads.

• Context — 262,144 positions for Hy-Memory-30B-A3B from its configuration file vs 128K native and 512K extended for Granite 4.2 30B.

• Weight footprint — about 60.1 GB across 51 BF16 safetensors shards for Hy-Memory-30B-A3B vs roughly 29B dense parameters in BF16 for Granite 4.2 30B, with FP8, NVFP4/MXFP4 and GGUF builds published alongside.

• Quantised options — none for Hy-Memory-30B-A3B; the team shipped one BF16 checkpoint and nothing else. Granite 4.2 30B has an official FP8 build, two 4-bit formats, and GGUF conversions from several community publishers.

• Reasoning controls — Hy-Memory-30B-A3B exposes a reasoning_effort switch but the project's own quickstart runs it at no_think with temperature 0.0; Granite 4.2 30B has three thinking modes including full chain-of-thought wrapped in think tags.

• Licence — Apache 2.0 for both, which removes one of the two questions a legal review would otherwise ask.

• Hosted availability — neither model is served by a hosted vendor endpoint. Granite 4.2 30B's card lists an inference provider; Hy-Memory-30B-A3B's states plainly that no provider deploys it.

• Published purpose — a memory writer against a general reasoning model. This is the row that decides everything above it.

Hardware is where the choice actually gets made

Here is the asymmetry that a spec sheet hides.

Hy-Memory-30B-A3B is 60 GB at BF16 with no quantised alternative. That is not a model you evaluate on a laptop, and it is not a model you spin up on a single workstation card to see whether the paper's claim holds. A team that wants to check Hy-Memory's numbers currently needs to provision roughly the same hardware as a small production deployment, before they know whether the thing works.

Granite 4.2 30B, dense as it is, ships in forms you can actually run today. The FP8 and 4-bit builds bring it inside a single accelerator's memory, and the GGUF conversions put a usable version on hardware people already own. That team shipped those builds deliberately — a vendor that publishes four quantisation formats is telling you it expects the model to be run by the person reading about it, not rented from a datacentre.

None of that makes Granite the better model. It makes Granite the cheaper model to find out about.

The non-obvious answer: these belong in the same system

An agent with long-term memory needs both functions, and the framework architecture makes the split explicit rather than theoretical.

A memory harness invokes a writer on the write path — fired every turn, short outputs, deterministic, and it must never invent a fact the user did not say. That is Hy-Memory-30B-A3B's entire job, and a 3B-active model on a no-think setting is exactly the right shape for it: cheap per call, because there are a lot of calls. Granite 4.2 30B is not competing for that slot. Where it belongs is the read path and the reasoning around it — deciding what to do with what is in the bank, planning, calling tools, producing the answer. Those are the frontier-facing calls where a dense reasoning model's depth is worth its weight.

Two models, two very different call profiles, and the interesting engineering question is how you put one key in front of both. That is what a routing layer is for. OrcaRouter's routing DSL composes several models into a single call — you can point the write path at a self-hosted Hy-Memory-30B-A3B endpoint and the read path at a hosted frontier model, and drive both from one API key across 200+ models with automatic failover if a backend degrades. Neither of these two models is in our catalogue and we host neither of them; the availability line for both is your own hardware or the vendor's own channels. What we cover is the other half — the hosted models that sit around a self-hosted writer — at 0% markup on provider list price.

That combination is worth understanding before either model is production-ready for you, because it is the same architecture whether the write path runs Hy-Memory-30B-A3B or a general model with a memory prompt bolted on. The router is indifferent. Swapping one for the other later should be a routing-table edit, not a rewrite.

Which one to look at first

If you have a long-running agent with a memory framework and the write path is currently a frontier model you are paying frontier prices to run on every turn, Hy-Memory-30B-A3B is the more interesting of the two and the one with a specific, quantified problem to solve. Go and look at it — but go with the understanding that your first task is building the hardware to test it on, and that no third party has yet confirmed the 55.49.

If you need one open-weight model that reasons, calls tools and runs inside a card you own, Granite 4.2 30B is the one to evaluate this week. It is two months old, its quantisations exist, and its published numbers are unreproduced — which is a normal state for a mid-size open model and not a warning sign on its own.

If you are building the whole thing, the honest answer is that you probably want both, in the two roles they were designed for, and the interesting work is the routing between them rather than the choice between them.