Strata-Sage-A1.5-GGUF

Strata-Sage-A1.5-GGUF

A Q4_K_M GGUF of the 35B Sage-A1.5 model made for the Strata inference engine, fitting a full 262K context on a 16 GB graphics card plus 64 GB of RAM. For people running big models locally.

Made by ykarout on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: This repository holds Sage-A1.5, a fine-tune of Qwen3.6-35B-A3B, as a 4-bit Q4_K_M GGUF made for the Strata inference engine. The model uses 256 experts and picks 8 per token, so about 3B parameters are active at a time. It also has a multi-token prediction layer. The card says the whole model and the full 262K context fit on a 16 GB card with 64 GB of RAM.

Who it suits: It suits people who run large mixture-of-experts models on their own PC and want long context and coding or agent sessions on one consumer graphics card.

Industry | Who uses it | How they use it | Example
Software | Developers | Run a 35B coding model locally with a long context | Working through a large codebase in one session
Agents | Agent builders | Keep long agent conversations without re-reading them each turn | An agent that continues from a cached state
Research | Inference engineers | Study expert caching and speculative decoding on a consumer GPU | Comparing the card's flags on their own card
Hobby computing | Local model enthusiasts | Run a big model with 16 GB of VRAM | Chatting with a 35B model at home

You can skip it if you want a plain download-and-run file, since the best path needs the Strata engine and a build step.

Where to use it:

• The Strata engine, on the q36-r2 branch, which the card says is the main target
• llama.cpp, since the card says it also runs as a normal qwen35moe GGUF
• Linux, or Windows through the project's start batch file
• A PC with a 16 GB graphics card and 64 GB of RAM for the full context

Use case | Who | What they get back
Long coding sessions | Developers | A context window of up to 262K tokens
Agent loops | Agent builders | Next turns that continue from cached state
Faster generation | Power users | Draft tokens from the built-in prediction layer

How to set it up:

• A 16 GB graphics card and 64 GB of RAM, per the card
• Disk space, about 21.7 GB for the model file
• The Strata project, built from its q36-r2 branch with its setup script
• Python, for the tokenizer tool and the download

1. Install the Hugging Face hub package with pip.
2. Get the Strata project on its q36-r2 branch and build the engine, using setup.sh on Linux or START-HERE.bat on Windows.
3. Download the model into a models folder.
4. Build the tokenizer from the downloaded model file.
5. Write the engine's config by hand, because the importer only takes another file type.

pip install -U huggingface_hub
hf download ykarout/Strata-Sage-A1.5-GGUF

hf download ykarout/Strata-Sage-A1.5-GGUF --local-dir models/sage
python tools/strata_tokenizer.py --gguf models/sage/Sage-A1.5-Q4_K_M-ssmbf16.gguf --out models/sage/tokenizer

How to use it: You start the Strata engine with a hand-written config that points at the model file and sets options such as the context size and cache type. The card lists the main options below.

Tool | What it does
--kv int8 | Stores the cache in 8-bit form so the full 262K context fits
--gqa-attn | Reads each cache row once per key-value head during decoding
--expert-profile | Starts with the profile's chosen experts already in video memory
--mtp | Lets the model draft tokens ahead, for sampled requests too
--snapshots | Lets an agent's next turn continue from the cached state

Example: A developer builds Strata, downloads the model and starts it with the config. They open a long coding session that fills a large part of the 262K window. The card says the engine keeps going from cached state on later turns instead of re-reading the whole conversation.

For newcomers and experts: If you are new to this, treat it as a project for experienced local-model users, since it needs a build and a hand-written config. The card also says the file runs in llama.cpp, which may be the easier first try.

If you know the field, the file keeps the original BF16 weights for 60 small DeltaNet gate tensors and is otherwise byte-identical to the official Q4_K_M. An 84 KB expert profile, learned from the model's own agent coding sessions, tells the engine which experts to keep in VRAM. A second round of engine work is on by default and adds tensor-core attention and expert caching.

Build the Strata engine
Download the GGUF and expert profile
Build the tokenizer
Write the engine config
Start a long session

Good to know:

• Limits: some round-two speedups need a GPU of compute level 8.0 or newer and the 8-bit cache.
• Size: the model file is 21.7 GB, larger than the 4-bit estimate on the page.
• Files: the repository also holds a small expert profile for the engine.
• License: Apache 2.0.
• Cost to run: none named.
• Data it reaches: it copies large model files to your computer and processes only the prompts you give it.

On Hugging Face, 13 November 2026

• Parameters: 35.5B
• Weights: about 17.8 GB at 4-bit (estimate)
• Formats: GGUF
• Downloads in the last 30 days: 5,466
• Likes: 14
• License: apache-2.0
• Based on: InternScience/Sage-A1.5
• Tags: gguf, strata, qwen35moe, agentic, conversational

Links

• Model: https://huggingface.co/ykarout/Strata-Sage-A1.5-GGUF
• Files: https://huggingface.co/ykarout/Strata-Sage-A1.5-GGUF/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download ykarout/Strata-Sage-A1.5-GGUF

Then follow the usage in its model card. Nothing in this kit runs by itself.