Maple-Preview says 5.31 GB. The repository weighs 40.43

On 4 August 2026, a model appears on Hugging Face that promises a great deal to anyone who wants inference inside their own perimeter: competitive reasoning, a 131,072-token context window, and a checkpoint declared at 5.31 GB. It is deepgrove/maple-preview, MIT licence, created and updated the same day. Then you list the repository’s files and read the weight index: 40.43 GB. Two numbers side by side — 5.31 GB on the card, 40.43 GB in the index — and the cut declared up front: this piece does not discuss the model’s quality. We are looking at what actually lands on disk.

What the card promises

The card opens like this: “Today we introduce Maple-Preview, an open-source 20B-A1B ternary-weight reasoning LLM. Maple-Preview has SOTA reasoning for its weight class and is even competitive with larger models. It solves IMO-level problems and runs at 200+ tokens/sec on a Mac mini M4, 5–16× faster than efficient models like Gemma 4, Qwen3.5, and gpt-oss.”

Four numbers are highlighted: “20B-A1B Model”; “218 tok/s M4 Mac mini”; “5.31 GB Checkpoint”; “131,072 Token context”. For anyone sizing a machine, 20B-A1B reads like this: twenty billion parameters in total, but roughly one billion active per token, because only 8 of 256 experts fire on each step.

The two numbers

We listed the repository’s files via the API and read model.safetensors.index.json, which declares in its own metadata "total_size": 40428060672 — 40,428,060,672 bytes, roughly 40.43 GB, spread across nine safetensors files: eight at around 5.00 GB and one at 0.43 GB. The config.json declares "dtype": "bfloat16" and "quantize": true.

The reading, stated precisely and without accusing anyone: the repository serves bfloat16 weights, and that is what you download; the 5.31 GB describes the checkpoint in its ternary form, the one the model is designed to run in. Both statements can be true at once. For anyone installing it, the gap is roughly seven and a half times, and bandwidth, disk space and the deployment path need to be sized on the 40.43 GB you actually download, not on the headline number.

This ratio between the two figures is our own reading, drawn from the artefacts published in the repository, not a claim made on the card. The right question to ask a publisher is not whether the number is true, but which artefact produces it. An honest caveat: in the published modelling code we found no packing of the weights into a ternary format; the tensors are declared bfloat16, and the index declares those 40.43 GB. We do not conclude that the 5.31 GB figure is wrong — we conclude that the artefact that produces it is not the one served by the repository you download today.

The note in the box

On the card, in a NOTE box: “The included Transformers implementation depends on Triton and FlashAttention and is intended for a compatible CUDA environment. The reported Apple Silicon result uses a separate on-device runtime.”

This is the central point of the piece, alongside the weight. The headline number — the Mac mini M4 — was not produced by the code you download: that code targets a CUDA environment, and the Apple Silicon result comes from a separate runtime, not included here. Whoever reads the headline pictures a Mac mini on a desk; whoever installs it finds that the served implementation wants Triton, FlashAttention and a compatible CUDA environment. Two different machines, two different budgets.

How we check it

Before proposing a model to a client, we list its files via the API and add up the declared bytes, without trusting the headline number. We read config.json to find out what type the tensors are declared in — bfloat16, int8, ternary — because that is what actually determines the space and compute required. We always open the LICENSE file, even when the card already names a familiar licence. And we look for the warning boxes on the card: that is where an honest author writes down the limits.

See the service · Talk to an engineer

What the authors declare themselves

The Evaluation section says the model “sets a new point on the Pareto frontier for both memory-to-performance and speed-to-performance”, with a comparison using “the dense output head across LCBv6, AIME 2026, HMMT 2026, and GPQA-D”.

But the same section adds, verbatim: “However, we note that this preview is focused primarily on raw reasoning and, as such, may underperform on agentic benchmarks. We intend to continue improving general performance through extended training before Maple’s full release.”

And the Limitations section: “This preview received minimal post-training for agentic tasks and only small-scale general reinforcement learning.”

For readers of these notes, the sentence that matters is “may underperform on agentic benchmarks”: anyone looking for agents that execute decisions is looking at precisely the test bench on which the model is declared weak. We say this without irony: it is declared by the authors themselves, and it is to their credit that they declare it.

The licence, for once, is not the problem

We downloaded the LICENSE file: 1,066 bytes, the text of the MIT License, “Copyright (c) 2026 deepgrove”, the grant “without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies”, the obligation to retain the copyright and licence notice, the clause “THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND”. No revenue threshold, no territorial exclusion, no automatic termination clause: unlike the ten-million-dollar threshold of the LFM Open License, or the European Union exclusion of MiniMax H3, the problem here is not the right to use it — it is what you download and what it runs on.

Two hundred and fifty-four likes, eight hundred and ninety-six downloads

At the time of our API query, five days after publication: 254 likes and 896 downloads. Plenty of people bookmarked it, almost no one took it. We present this as an observed fact, not a judgement: it is the typical profile of an announcement that draws interest before it draws use — and the 40 GB to download is one plausible explanation among others, not the certain one.

What to do about it

Add up the bytes of every file in the repository, not just the number on the card, before planning bandwidth and disk space.
Read config.json to find out what type the tensors are declared in: that, not the headline label, determines the real cost.
Ask which artefact produces the announced size figure, and on what runtime it was measured.
Check the environment on which the declared speed was measured: a separate runtime not included in the repository is a different commitment from a ready-to-use implementation.
Look for the card’s warning boxes before the charts: that is where an honest author writes down the limits.

The two axes, applied

Complying: verifying the licence, provenance, real size and execution environment of every model in production becomes a check that runs on the client’s own systems, with a dated register — artefact, repository, revision, licence, actual bytes, required runtime, date of verification — ready to show an inspector or a client.

Deciding: the same system brings the organisation’s models, data, documents and systems into a single operating model, on which AI agents execute decisions with a human operator in command, for large enterprises, defence, government and healthcare. The multi-model argument shows up concretely here: if a model is declared weak precisely on agentic tasks, you swap the component, not the project, because the ontology, the data and the processes remain the client’s.

Always in two delivery modes — on-premise, on self-contained machines with no deep integration into the client’s network, or dedicated cloud with a data centre in Italy — always with shared management. It is the same system we propose to government and public administration.

Assessing Maple-Preview, or another open-weight model, and want to know how much it actually weighs and what machine it runs on? Talk to one of our engineers: the first session is at no cost.