Why this model exists
Moonshot released moonshotai/Kimi-K2.7-Code
in native INT4 — pack-quantized compressed-tensors, ~595 GB. That is excellent for serving
and awkward for everything else. Requantizing to another format, fine-tuning, merging, or running
numerical comparisons all want a standard full-precision checkpoint, and there wasn't one.
This repository is that checkpoint: the official INT4 release dequantized to bfloat16 and shipped
as an ordinary transformers model.
It is the only transformers-loadable BF16 safetensors build of K2.7 Code we are aware of.
Thireus/Kimi-K2.7-Code-THIREUS-BF16-SPECIAL_SPLIT carries comparable byte volume but is 998
per-tensor GGUF shards for a quant-mixing tool, with no config.json and no
model.safetensors.index.json — it does not load as a model. Everything else on the Hub is either
the 595 GB INT4 original, a mirror of it, or a quantization of it.
Specifications
Table | |
|---|
| Architecture | KimiK25ForConditionalGeneration — MoE, multimodal (image-text-to-text) |
| Base | moonshotai/Kimi-K2.7-Code — official, © Moonshot AI |
| Upstream format | native INT4, pack-quantized compressed-tensors, ~595 GB / 64 shards |
| Transform | Faithful dequantization to bfloat16 · quantization_config removed · dtype set to bfloat16 |
| This repo |
Tokenizer (tiktoken.model, tokenization_kimi.py), chat_template.jinja, generation_config.json,
the modeling and configuration modules, preprocessor_config.json and tool_declaration_ts.py all
ship with the weights, so a serving stack that honours the packaged assets will not silently fall
back to a generic template.
What dequantization does and does not do
This matters and is routinely misread, so it is stated plainly:
What it does. Every INT4 value in the official release is expanded to its exact bfloat16
representation. Nothing is approximated, dropped, or re-derived. Load this and you get the same
model Moonshot published, in a format standard tooling can operate on.
What it does not do. Upcasting cannot recover information that was never in the INT4 file.
This is a BF16-formatted checkpoint, not a BF16-trained one. If Moonshot holds a higher-precision
master, this is not it, and no dequantization could produce it. Anyone quoting "full precision" as
though it implied more information than the INT4 source is wrong, and we would rather say so on our
own card than have someone else say it for us.
What it is genuinely good for:
- Requantization base — GGUF, NVFP4, MXFP4, FP8, AWQ, GPTQ. Most quantization tooling expects
BF16/FP16 input and chokes on
compressed-tensors INT4.
- Fine-tuning and merging — LoRA, full fine-tune, or model merging, none of which work cleanly
against pack-quantized weights.
- Numerical research — reference-logit comparisons, quantization-error studies, layer analysis.
Lineage
Table | |
|---|
| Base | Official moonshotai/Kimi-K2.7-Code (INT4) |
| Applied | Dequantization INT4 → bfloat16 · quantization_config stripped from config.json |
| Not applied | Fine-tuning · ablation · refusal modification · distillation · merging · pruning |
| Format | HF safetensors · bfloat16 |
On refusal behaviour: unchanged from upstream. See the notice at the top of this card.
Capabilities and evaluation
All architecture, capability and evaluation claims belong to Moonshot AI and are published on
the original model card. Blackfrost has run no
independent benchmark on this checkpoint and makes no capability claim of its own.
Because the transform is a format conversion with no behavioural change, upstream numbers should
carry — but that is a reasonable expectation, not something we have measured. If you need it
verified for your use, ask.
Deployment notes
- Hardware. ~2.05 TB of weights. This is a base artifact for offline work, not a serving target — for inference, use Moonshot's INT4 release or a quantization derived from this one.
- Disk. Allow 2.2 TB. 64 shards.
- Loading. Standard
transformers with trust_remote_code=True (the architecture ships its own modeling modules).
- Integrity. Verify shard count (64) and byte totals against
model.safetensors.index.json before attributing a load failure to the weights.
Licence
Modified MIT, inherited from
moonshotai/Kimi-K2.7-Code.
Moonshot's terms apply to this derivative and travel with it, along with any onward derivative you
create. LICENSE and THIRD_PARTY_NOTICES.md ship in this repository.
Full credit for the model itself to Moonshot AI. Blackfrost's contribution here is the format
conversion and nothing else.
Disclaimer
No warranty of any kind. Provided "as is", without warranty express or implied, including
fitness for a particular purpose.
No behavioural modification, and no safety claim either way. This checkpoint carries upstream
Kimi K2.7 Code's safety behaviour unchanged. Blackfrost has neither strengthened nor reduced it, and
publishes no refusal measurement for it.
No independent capability measurement. Upstream evaluation figures are Moonshot's. Blackfrost
has not reproduced them on this checkpoint.
Modification by a recipient is your responsibility. Any further quantization, fine-tuning,
merging, ablation or alteration produces an artifact Blackfrost has not evaluated and does not stand
behind — including any refusal-behaviour change a recipient introduces. Responsibility transfers
entirely to whoever produced it.
Upstream licence obligations travel. Moonshot's Modified MIT terms bind you and every derivative
you create from this repository.