Corvid-Magpie-9B-gguf

Corvid-Magpie-9B

Corvid-Magpie-9B is a compact local language model based on Qwen3.8-9B-Distill, combining the Qwen3.5-9B hybrid Gated DeltaNet and attention architecture with the behavior learned through Qwen3.8 distillation.

It is designed for fast local inference on ordinary desktop hardware. On an RTX 3060 8GB with a Ryzen 7 5800X3D and 32GB of RAM, Magpie reaches up to 41.6 tok/s decoding with MTP speculative decoding and processes prompts at roughly 1,250–1,430 tok/s.

The model has a native 262,144-token context window.

Architecture

Magpie uses the Qwen3.5-9B qwen35 architecture, combining Gated DeltaNet with conventional attention.

The distributed weights are unchanged from the Qwen3.8-9B-Distill GGUF:

Qwen3.8-9B-Q4_K_M.gguf

The GGUF is approximately 5.78GB.

The model also includes the native MTP prediction layer from Qwen3.8-9B-Distill, stored in the blk.32.nextn.* tensors with one prediction layer.

A separate 918MB F16 vision projector is available from the base model, but the vision path has not been tested as part of Magpie.

Speculative decoding

Magpie includes its native MTP layer and can use it for speculative decoding through upstream llama.cpp.

With MTP disabled, decoding reaches approximately 28.8–28.9 tok/s on the reference system.

Using a draft length of two increases throughput to 41.6 tok/s on code and 37.3 tok/s on prose.

A draft length of four does not provide a consistent benefit. Code reaches 41.4 tok/s, while prose falls to 32.9 tok/s.

A draft length of two is therefore the recommended configuration.

Local performance

Measurements were taken on an NVIDIA RTX 3060 8GB, Ryzen 7 5800X3D, 32GB DDR4, and NVMe SSD, with approximately 1.1GB of VRAM occupied by another resident process throughout testing.

Prompt processing reaches approximately 1,250–1,430 tok/s depending on workload.

The long-context runs below were measured with Qwen3.5-9B, which shares Magpie's architecture and quantization:

• At 64K context, a prompt was processed in 57.7 seconds, corresponding to approximately 1,115 tok/s.
• At 100K context, a prompt was processed in 99 seconds, corresponding to approximately 1,016 tok/s.

Long-context caching

Magpie supports in-memory prefix caching through llama.cpp.

In a test using a 14.6K-token prefix, the next question took approximately 0.15 seconds with the prefix cached, compared with approximately 10.3 seconds when the same prefix was processed from scratch.

This allows repeated work over large shared prefixes without reprocessing the entire context.

Quality

Magpie was evaluated using a 20-task Python coding suite with hidden tests, greedy decoding, and a 6,144-token output limit.

Magpie completed 18 of 20 tasks. Both failures reached the output-token limit while still reasoning rather than producing incorrect code.

In the same evaluation, Qwen3.5-9B completed 8 of 20 tasks without a reasoning budget and 18 of 20 when given a 2,048-token reasoning budget.

These are small targeted evaluations and should not be interpreted as standardized benchmark scores.

Recommended runtime

Magpie is tested with upstream llama.cpp.

A recommended configuration for the reference system is:

llama-server \
  -m Qwen3.8-9B-Q4_K_M.gguf \
  -ngl 99 \
  -fa on \
  -nkvo \
  -ctk q8_0 \
  -ctv q8_0 \
  -c 65536 \
  -b 2048 \
  -ub 512 \
  -t 8 \
  --spec-type draft-mtp \
  --spec-draft-n-max 2

-nkvo keeps the KV cache in system RAM and reduces GPU memory pressure.

For contexts above 64K, use:

-ctk q4_0 -ctv q4_0

A reasoning budget can optionally be enabled with:

--reasoning-budget 2048

Hardware

Magpie has been tested on:

• NVIDIA RTX 3060 8GB
• AMD Ryzen 7 5800X3D, 8 cores / 16 threads
• 32GB DDR4 RAM
• NVMe SSD

The 5.78GB GGUF fits within this class of system while leaving room for the runtime, KV cache, and MTP speculative decoding.

For large context windows, system-memory KV is recommended on 8GB GPUs.

Limitations

The native context length is 262,144 tokens, but local testing has currently reached 100K tokens. 128K, 192K, and 256K contexts have not yet been measured.

GPU-resident KV becomes increasingly restrictive at large context sizes on an 8GB GPU.

Disk-based llama.cpp slot save/restore has not been reused successfully for this hybrid architecture in the current runtime. In-memory prefix caching is supported and tested.

The vision projector available from the base model has not been tested with Magpie.

The quality measurements come from small evaluation sets and should not be treated as broad benchmark results.

License

Corvid-Magpie-9B is based on empero-ai/Qwen3.8-9B-Distill, released under the Apache-2.0 license.

Users should consult the original model documentation and license when using or redistributing this derivative.

Current status

This is a very rough draft of the Magpie model card based on the current experimental weights and measurements.

The weights, architecture configuration, runtime recommendations, context results, and evaluation data may change as Magpie development continues.

This card must be updated when the Magpie weights are finalized. Final model-specific details, including the exact architecture, parameter counts, quantization, runtime configuration, context validation, and quality measurements, should be regenerated from the finalized GGUF and final evaluation results rather than carried forward from this draft.