Instructions to use malaiwah/glm5-next-tiny-random-bf16 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use malaiwah/glm5-next-tiny-random-bf16 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="malaiwah/glm5-next-tiny-random-bf16")

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("malaiwah/glm5-next-tiny-random-bf16")
model = AutoModelForMultimodalLM.from_pretrained("malaiwah/glm5-next-tiny-random-bf16", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use malaiwah/glm5-next-tiny-random-bf16 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "malaiwah/glm5-next-tiny-random-bf16"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "malaiwah/glm5-next-tiny-random-bf16",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/malaiwah/glm5-next-tiny-random-bf16

SGLang

How to use malaiwah/glm5-next-tiny-random-bf16 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "malaiwah/glm5-next-tiny-random-bf16" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "malaiwah/glm5-next-tiny-random-bf16",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "malaiwah/glm5-next-tiny-random-bf16" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "malaiwah/glm5-next-tiny-random-bf16",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use malaiwah/glm5-next-tiny-random-bf16 with Docker Model Runner:
```
docker model run hf.co/malaiwah/glm5-next-tiny-random-bf16
```

GLM5-Next: a tiny toolchain fixture

A small, independently initialized random-weight reference model for learning, debugging, and reproducing QFS capture workflows. It is a base/root fixture, not a quantized child.

These weights are untrained, not an assistant, and not a language-quality benchmark. Generated text has no useful semantic quality. No upstream trained weights or training data are implied by an architecture name.

Weight lineage

This checkpoint was initialized directly for an architecture test. It was not fine-tuned from a production model and does not inherit that model's trained weights. Architecture/configuration lineage is documented separately from weight lineage.

Browse the Random Architecture Fixtures collection. A random base may also serve as the common source for an aligned quantization family.

At a glance

Property	Observed value
Artifact role	Base/reference model; capture role `root`
Serialized top-level weight files	876,108 bytes (0.836 MiB); metadata, tokenizer and evidence excluded
Generated parameters	422,430
Saved semantic tensors	209 (parameters and buffers are not interchangeable)
Fixture vocabulary	266 tokens; independent byte tokenizer, not upstream vocabulary
CPU stack	Python 3.12; Torch 2.11.0+cpu; Transformers 5.16.1; two Torch threads in the recorded capture workflow
Remote model code	Not required: native Transformers class behind QFS

Size is serialized artifact size, not runtime RAM or a capacity/performance guarantee. Packed-array element counts are not model parameter counts.

What is actually included

Complete native Glm5NextForConditionalGeneration wrapper with five KDA/KDA/KDA/DSA/KDA layers, dense/MoE routing, four-stream mHC and pooled sparse attention. Real small vision weights are present but evidence is text-only. The head is untied; MTP is absent. Native-required FP32 state remains FP32.

The repository file inventory includes config.json, generation_config.json, tokenizer.json, tokenizer_config.json, build-manifest.json, requirements-cpu.txt. Exact build/runtime/license inventories are linked below. A file may describe historical provenance without being an executable entry point.

Good community uses—and boundaries

Learn how to download pinned artifacts, seal a small synthetic token panel, capture hidden states and replay a full vocabulary head.
Debug model-family adapters, strict tensor loading, storage decoders, or reproducibility tooling without downloading a production-sized checkpoint.
Reproduce a narrowly scoped result, report an adapter/reader regression, and retain the source, panel and runtime identities needed to explain it.

Not established: trained-model accuracy; useful instruction following; quantizer optimization quality; original production-weight compatibility; GPU/NPU/serving-kernel parity; cross-hardware determinism; long-context behavior outside the recorded panel; throughput or paid-compute admission.

Additional build caveats:

Untrained random model; no language or vision quality claim.
Real vision tower present but all capture and boundary probes are text-only.
Zero MTP layers; no orphan tensors.
Build equality is not CPU capture evidence.

Model family, root dataset and evidence

This model is the base/root of its own random fixture family, not a reproduction of the trained upstream model. The fidelity-root dataset repository is the family reference location. A link is not a claim that registration or publication has completed.

The historical CPU evidence bundle retains two independent captures at first/ and repeat/, plus comparison/. Its repository root is a receipt bundle, not a single canonical QFS dataset. Those recorded same-machine/same-stack forced comparisons reported 0.0 nats on 252 synthetic scored positions; that is not a trained-quality result or a transferable hardware floor. The original detailed receipt and caveats remain authoritative.

Runtime requirements and safe local reproduction

Replay the published evidence without loading a model

This uses QFS's existing NumPy FP64 comparator in a Torch-free environment. It reads the stored hidden states and each side's own head. No model forward, remote model code, GPU, upload or registry mutation is involved. Runtime receipts name the actual backend; last-bit differences from another FP64 implementation are not a new quality claim. Synthetic exact controls remain zero.

Set QFS to a reviewed Quant Fidelity Suite checkout and use Bash:

: "${QFS:?Set QFS to your reviewed QFS checkout}"
WORK=$(mktemp -d)
export OMP_NUM_THREADS=2 MKL_NUM_THREADS=2 OPENBLAS_NUM_THREADS=2
python3.12 -m venv "$WORK/replay-env"
"$WORK/replay-env/bin/pip" install 'numpy==2.5.3' 'huggingface-hub==1.30.0'
"$WORK/replay-env/bin/hf" download malaiwah/qfs-fixture-root-captures-v1 --repo-type dataset \
  --revision f53b204091c988ce4a2161af81886f3018745559 --include 'roots/glm5_next/**' --local-dir "$WORK/evidence"
"$WORK/replay-env/bin/python" "$QFS/bin/fidelity_dataset.py" verify \
  "$WORK/evidence/roots/glm5_next/first" --verify-tensors
"$WORK/replay-env/bin/python" "$QFS/bin/fidelity_dataset.py" verify \
  "$WORK/evidence/roots/glm5_next/repeat" --verify-tensors
"$WORK/replay-env/bin/python" "$QFS/bin/fidelity_dataset.py" compare \
  --reference "$WORK/evidence/roots/glm5_next/first" \
  --candidate "$WORK/evidence/roots/glm5_next/repeat" \
  --out "$WORK/replayed" --device cpu --replay-device numpy --replay-dtype float32 \
  --vocab-chunk 8192 --verify-tensors --self-compare --force-compute

Reconstructed format comparisons are intentionally advisory and normally return exit code 2 while writing a valid receipt. Inspect that receipt; do not silence refusals or interpret an advisory result as a production-quality ranking.

Capture the actual checkpoint

Capture uses a separate pinned Torch CPU environment. The input below is the original token-panel format, not a sealed capture's internal panel/ folder. The native source, tokenizer and model revisions remain explicit. Set AUTHOR to your own HF handle; the dataset repository argument is attribution only and nothing is uploaded by these commands.

: "${AUTHOR:?Set AUTHOR to your Hugging Face handle}"
"$WORK/replay-env/bin/hf" download malaiwah/glm5-next-tiny-random-bf16 --revision 4c31348e3beb1a8a6bd73d055464362953d768ea --local-dir "$WORK/model"
"$WORK/replay-env/bin/hf" download malaiwah/glm5-next-tiny-random-bf16 --revision 4c31348e3beb1a8a6bd73d055464362953d768ea --local-dir "$WORK/source"
"$WORK/replay-env/bin/hf" download malaiwah/qfs-fixture-root-captures-v1 --repo-type dataset \
  --revision f53b204091c988ce4a2161af81886f3018745559 --include 'requirements-capture.txt' --include 'roots/glm5_next/input-panel/**' \
  --local-dir "$WORK/inputs"
python3.12 -m venv "$WORK/capture-env"
"$WORK/capture-env/bin/pip" install -r "$WORK/inputs/requirements-capture.txt"
"$WORK/capture-env/bin/python" "$QFS/bin/fidelity_dataset.py" architectures prepare \
  --architecture glm5_next --model-dir "$WORK/model" \
  --model-repository malaiwah/glm5-next-tiny-random-bf16 --model-revision 4c31348e3beb1a8a6bd73d055464362953d768ea \
  --panel "$WORK/inputs/roots/glm5_next/input-panel" --tokenizer-root "$WORK/source" \
  --author "$AUTHOR" --dataset-repository "$AUTHOR/glm5-next-tiny-random-bf16-capture" \
  --dataset-id "fidelity--$AUTHOR.glm5-next-tiny-random-bf16" --out "$WORK/workflow"

Inspect workflow.json. This launcher executes its exact capture/verification commands and selects the Torch-free interpreter only for the final comparison:

export OMP_NUM_THREADS=2 MKL_NUM_THREADS=2 OPENBLAS_NUM_THREADS=2
"$WORK/replay-env/bin/python" - "$WORK/workflow/workflow.json" <<'PY'
import json, subprocess, sys
workflow = json.load(open(sys.argv[1]))
for step in workflow["commands"]:
    argv = list(step["argv"])
    if step["step"] == "compare":
        argv[0] = sys.executable
    result = subprocess.run(argv)
    if result.returncode:
        raise SystemExit(result.returncode)
PY

Use the actual root at malaiwah/glm5-next-tiny-fidelity-root-v1@3990bcf5b82667cc359046898a652ee8a84921a7. The community collection groups models and captures. Custom code, where required above, is explicitly pinned and executed only after your consent; hash verification is provenance, not a sandbox.

Licensing and detailed provenance

The fixture repository retains its mit license in LICENSE. This covers the fixture only according to that exact text; architecture inspiration is not relicensing of upstream weights, cards, code, or configuration. Dependencies retain their own licenses (native Transformers implementation: Apache-2.0). No upstream trained tensors are claimed to be copied.

Immutable provenance, historical cards, source inventories and full caveats

Model/card snapshot used while authoring: malaiwah/glm5-next-tiny-random-bf16@4c31348e3beb1a8a6bd73d055464362953d768ea.
Full preserved earlier model card, SHA-256 65da26c6b27e8c6d39ec300d021efe890ff1c295b1102d5df608ac31a36d2128. This is an immutable historical record, including original build pins, measured resource tables, command logs, limitations and failed-attempt provenance. Historical publisher commands are not part of the local-use recipe above.
build-manifest.json.
qfs-source.json.
cpu-reproduction-summary.json.

Selected original provenance fields (full tensor/component evidence remains in the linked inventories):

{
  "architecture_reference": "inference-optimization/GLM-5.3-Flash-0.1B-A0.1B@7c3a6d3dc51732dd8ab230888e06ba8c93a381ac",
  "fp32_retained_tensors": [
    "model.language_model.layers.0.self_attn.conv1d.weight",
    "model.language_model.layers.0.self_attn.forget_gate.dt_bias",
    "model.language_model.layers.0.self_attn.forget_gate.A_log",
    "model.language_model.layers.1.self_attn.conv1d.weight",
    "model.language_model.layers.1.self_attn.forget_gate.dt_bias",
    "model.language_model.layers.1.self_attn.forget_gate.A_log",
    "model.language_model.layers.2.self_attn.conv1d.weight",
    "model.language_model.layers.2.self_attn.forget_gate.dt_bias",
    "model.language_model.layers.2.self_attn.forget_gate.A_log",
    "model.language_model.layers.3.mlp.gate.e_score_correction_bias",
    "model.language_model.layers.4.self_attn.conv1d.weight",
    "model.language_model.layers.4.self_attn.forget_gate.dt_bias",
    "model.language_model.layers.4.self_attn.forget_gate.A_log",
    "model.language_model.layers.4.mlp.gate.e_score_correction_bias"
  ],
  "generator_sha256": "2958ca3099779a8d81911f2f9d2fe1dba31609880e21e1bad2d501df6938364c",
  "limitations": [
    "Untrained random model; no language or vision quality claim.",
    "Real vision tower present but all capture and boundary probes are text-only.",
    "Zero MTP layers; no orphan tensors.",
    "Build equality is not CPU capture evidence."
  ],
  "parameter_count": 422430,
  "seed": 20260907,
  "versions": {
    "safetensors": "0.8.0",
    "tokenizers": "0.23.2",
    "torch": "2.11.0+cpu",
    "transformers": "5.16.1"
  }
}

Downloads last month: 28

Safetensors

Model size

422k params

Tensor type

F32

BF16

Collections including malaiwah/glm5-next-tiny-random-bf16

QFS test fixtures and reproducible captures

Collection

Tiny random models, quantized format fixtures and verified CPU captures for QFS. Pipeline tests, not assistants or quality benchmarks. • 64 items • Updated about 15 hours ago

QFS Random Architecture Fixtures

Collection

Independent tiny random native architectures and qualified CPU roots. No trained weights or production-model fine-tuning lineage. • 25 items • Updated about 15 hours ago