Oblivion

A single fused multimodal language model: a MuseGlimmer-30B host trunk with a Qwen3.8-27B donor block (Gated DeltaNet–attention blocks) spliced in after text-layer 35 and a Gemma4-31B donor block (hybrid local/global attention blocks) after layer 47. Both donor blocks are always applied (RMS-bounded, gated at 0.25) — one model, one forward pass. Images are supported through MuseGlimmer's native vision tower.

Goal. Oblivion is built to deliver strong performance while minimising the risk of reasoning-to-oblivion — runaway chain-of-thought that burns the token budget on excess reasoning before ever reaching an answer — while enabling speed-ups through speculative-decoding support and providing a diverse architecture that blends three families of attention (softmax, Gated DeltaNet linear-attention, and local/global).

These are the assembled bf16 weights (a self-contained checkpoint: MuseGlimmer trunk + the two donor blocks + tokenizer / chat template / image-processor config). Serve them at full precision (bf16), or in FP8 by adding --quantization fp8 at serve time — a dynamic W8A8 quantization applied on load, so the model fits a single GPU and there is no separate FP8 checkpoint to download.

Parameter count: ~42 B total — a ~30 B MuseGlimmer trunk plus ~12 B of Qwen3.8-27B + Gemma4-31B donor weights (donors/). Hugging Face's auto-computed "Model size" shows only ~30 B because it counts the safetensors indexed in model.safetensors.index.json (the trunk); the donor weights are loaded by the plugin and are not part of that index, so they aren't included in the widget's total.

Serving

This model runs under vLLM via the Oblivion plugin — which is bundled in this repo under plugin/, so nothing else needs downloading. You do need a vLLM build with MuseGlimmer support (Oblivion's OblivionForCausalLM subclasses it); the plugin declares no deps of its own so it never shadows that build.

# 1. download the checkpoint + bundled plugin
huggingface-cli download IcyApril/Oblivion --local-dir Oblivion

# 2. install the plugin (registers OblivionForCausalLM; uses your existing vLLM/torch)
pip install ./Oblivion/plugin

# 3. serve — full precision (bf16), with the recommended flags
VLLM_PLUGINS=oblivion_register vllm serve ./Oblivion \
  --mamba-cache-mode=align --trust-remote-code \
  --reasoning-parser muse_glimmer --generation-config auto \
  --enable-auto-tool-choice --tool-call-parser muse_glimmer

# or FP8 (dynamic, fits one GPU): add --quantization fp8

The Qwen donor uses a Gated-DeltaNet (linear-attention) layer, which makes the model hybrid — hence --mamba-cache-mode=align is required.

Recommended vLLM configuration. The serve command above adds four flags:

• --reasoning-parser muse_glimmer surfaces the model's chain-of-thought as a separate reasoning_content field instead of letting it leak into the answer.
• --generation-config auto loads the checkpoint's generation_config.json so <|eot|> is honoured as a stop token and each turn ends cleanly; without it a reply can run past its answer.
• --enable-auto-tool-choice --tool-call-parser muse_glimmer parse MuseGlimmer's native ATEM tool calls (<atem:invoke> blocks) into OpenAI-style tool_calls for function calling. Channel-scoped (tool markup inside the to=self reasoning channel is ignored) and a companion to the reasoning parser; a no-op when a request supplies no tools.

The --reasoning-parser muse_glimmer --generation-config auto pair is the configuration used for the Terminal-Bench runs below.

Speculative decoding (DFlash)

Oblivion works out of the box with MuseGlimmer's official DFlash drafter, meta-models/Muse-Glimmer-30B-assistant — a block-diffusion model that proposes whole 16-token blocks verified in parallel. It transfers to the fused model with no retraining (it reads the MuseGlimmer trunk's hidden states), and it is lossless: every drafted token is verified against Oblivion's own logits.

VLLM_PLUGINS=oblivion_register VLLM_USE_V2_MODEL_RUNNER=1 \
vllm serve <path-to-this-checkpoint> \
  --mamba-cache-mode=align --trust-remote-code --quantization fp8 \
  --reasoning-parser muse_glimmer --generation-config auto \
  --enable-auto-tool-choice --tool-call-parser muse_glimmer \
  --speculative-config '{"method":"dflash","model":"meta-models/Muse-Glimmer-30B-assistant","num_speculative_tokens":16}'

VLLM_USE_V2_MODEL_RUNNER=1 is required — because Oblivion is hybrid it spans multiple KV-cache groups, which the V1 DFlash proposer rejects; the V2 model runner handles it. --quantization fp8 is optional — DFlash is independent of the target's precision, so drop the flag for bf16 or keep it for fp8. On a single GH200 this is 2.20× end-to-end (see Benchmarks); mean accepted length ~2.7 (chat) to ~3.7 (code/reasoning).

Benchmarks

Initial results. Each benchmark uses one shared harness/environment across the models unless noted; token figures are output tokens (input excluded).

GPQA Diamond — 198 questions, 32k-token limit

GPQA Diamond ran with max_tokens=32768; all models used the same environment and harness.

Model	Accuracy (all Qs)	Truncated (@32k)	Output tokens/answer	Output tokens/correct
Oblivion	85.4% (169/198)	3	5,932	4,796
Glimmer	83.8% (166/198)	4	5,961	4,895
Qwen3.8-27B	82.3% (163/198)	24	11,428	7,963

Truncated = finish_reason=length (hit the 32k cap). Oblivion leads on accuracy and is the most token-efficient; Qwen truncated 12% of answers and spent ~2× the tokens.

Terminal-Bench 2.0 — 89 tasks

Oblivion was served under FP8 with DFlash enabled and the recommended --reasoning-parser muse_glimmer --generation-config auto; the other models were served via OpenRouter. The harness ran on Modal for Qwen and Glimmer, and on an M1 Pro Mac (emulating arm64) for Oblivion.

Model	Accuracy (all tasks)	Output tokens/answer	Output tokens/correct
Qwen3.8-27B	42.7% (38/89)	39,244	22,764
Oblivion	39.3% (35/89)	14,909	10,013
Glimmer	39.3% (35/89)	13,132	10,624

Oblivion ties Glimmer and is the most output-efficient per correct answer (~10k vs Qwen's ~23k). Output tokens only — total (input+output) is dominated by per-turn context resends and isn't a clean efficiency measure.

DFlash speculative-decoding speed — Oblivion / Glimmer serving

Config	800-token latency	Throughput	Speedup
Base (no DFlash)	23.81 s	33.6 tok/s	1.00×
DFlash (num_spec=16)	10.84 s	73.8 tok/s	2.20×

License

Released under Apache-2.0, matching the MuseGlimmer-30B, Qwen3.8-27B, and Gemma4-31B base models this checkpoint is derived from — each of which is Apache-2.0 licensed.