# Flash Load: Smart Lazy Loading for 200GB Step 3.7 Flash Q8 MLX on Apple 128GB RAM

Authors: [Arjun Reddy](mailto:arjun@osmapi.com), [Kesavan Sekar](mailto:kesavan@osmapi.com), [Mahesh Kumar](mailto:md24d011@smail.iitm.ac.in), [Venkatesh Rajendran](mailto:crv@osmapi.com) and [Pritam Christpin](mailto:pritam@osmapi.com)

Research attribution: [osmAPI Research Team](https://osmapi.com)

Base model: [stepfun-ai/Step-3.7-Flash](https://huggingface.co/stepfun-ai/Step-3.7-Flash)

Live MLX quant artifacts:

- [osmapi/Step-3.7-Flash-MXFP4-mlx](https://huggingface.co/osmapi/Step-3.7-Flash-MXFP4-mlx)
- [osmapi/Step-3.7-Flash-OptiQ-3.7bpw-mlx](https://huggingface.co/osmapi/Step-3.7-Flash-OptiQ-3.7bpw-mlx)

This post documents a local research run on an M3 Max MacBook Pro with 128 GiB unified memory. The goal was deliberately narrow: execute the q8 MLX version of Step 3.7 Flash under a hard 96 GiB model-memory ceiling plus a 2 GiB context/KV ceiling by lazily loading routed experts instead of fully materializing the model.

We call this specific policy **Flash Load**: a routing-aware expert-residency method that keeps a protected Backup/Standby floor in memory, predicts a small Up Next set, and loads Inactive q8 experts from disk by exact byte offset only when the router asks for them.

## TLDR

- **Flash Load** is our name for this method: route first, keep only the dense core plus a protected expert floor in RAM, predict a small Up Next set, and pull cold q8 expert slices from flash storage only when the router proves they are needed.
- Step 3.7 Flash is a sparse MoE VLM from StepFun. The public architecture reports a 198B-class model, a Step-3.5-derived language backbone, 45 language layers, 42 routed MoE layers, 288 routed experts per MoE layer, and top-8 expert activation per token.
- Our local q8 MLX tensor set is 199.74 GiB. Loading it naively is outside the target budget.
- We indexed all 12,096 routed experts and categorized them into Active, Up Next, Backup/Standby, and Inactive.
- Active is dynamic: it means "the router selected this expert now." Backup/Standby is durable: 514 q8 experts stay protected in RAM. Inactive means the expert remains on disk unless the router actually asks for it.
- Flash Load is not a claim that nobody has streamed MoE experts before; it is the name for our Step 3.7 Flash q8 + MLX + protected-category runtime.
- A clean indexed run completed with 64 prompt tokens and 8 decode steps using q8 KV. Peak external memory stayed far below 100 GiB: 42.0 GiB by `top`, 43.52 GiB by `vm_stat`, and 29.43 GiB process RSS.
- The measured model-path estimate was 38.63 GiB and the context/KV cache was 7.05 MB, both inside the 96 GiB + 2 GiB target.
- Throughput was not production-fast yet: TTFT 41.96 s, prefill 1.65 tok/s, decode 0.693 tok/s. The proof is about memory residency first. The speed work begins after this.

## Abstract

Large sparse MoE models create an interesting local-inference problem. Per token, they only need a small fraction of their parameters, but common inference stacks often assume that the full checkpoint, or at least very large portions of it, should be resident. Step 3.7 Flash makes that tension visible on Apple Silicon: the model is sparse enough to invite selective residency, but its q8 tensor set is still much larger than a 96 GiB target budget.

Inspired by Apple researchers' [LLM in a Flash](https://arxiv.org/abs/2312.11514), we explored whether the "flash as a memory extension" idea can be adapted to a modern routed MoE. Our unit of paging is not a whole layer and not a matrix row block. It is a routed expert slice: a small q8 tensor pack containing the gate, up, and down projections for one expert in one MoE layer.

We built an indexed expert map, a protected Backup/Standby floor, a policy cache, q8 compressed KV accounting, clean-baseline macOS memory gates, and an MLX smoke runner. The final clean indexed proof executed a bounded Step 3.7 Flash q8 language path under the target memory envelope while recording TTFT, prefill throughput, decode throughput, policy-cache residency, indexed load counts, and platform memory.

## Prior Art And Naming

The honest prior-art answer is: yes, several people are exploring MoE expert streaming and offloading on Apple Silicon and elsewhere.

Relevant adjacent work includes Apple's [LLM in a Flash](https://arxiv.org/abs/2312.11514), [Flash-MoE](https://github.com/Anemll/flash-moe)-style SSD expert streaming, [anemll-flash-mlx](https://github.com/Anemll/anemll-flash-mlx), [MLX-Flash](https://pypi.org/project/mlx-flash/), the [FlashMoE cache-replacement paper](https://arxiv.org/abs/2601.17063), general fine-grained expert offloading work such as [fMoE](https://arxiv.org/abs/2502.05370), and llama.cpp-side MoE CPU/GPU offload and hot-cache experiments.

What we did not find in this sweep was the exact same method on the exact same target: Step 3.7 Flash q8 on Apple MLX, with a generated per-expert byte-offset index, explicit Active/Up Next/Backup/Inactive categories, a protected 514-expert Backup floor, clean-baseline macOS memory gates, q8 KV accounting, and a measured under-100 GiB proof.

So we use **Flash Load** as the name for this method, not as a broad claim of inventing MoE expert streaming from scratch. In one sentence:

Flash Load is a category-aware MoE residency policy for local inference where the runtime keeps the dense core and a protected expert floor resident, predicts near-future experts, and fetches cold expert slices from flash storage only when router evidence justifies the load.

## Source Map

This project used a mix of primary model sources, systems papers, runtime documentation, and community research leads. I am separating them here because they did different jobs in the research.

### Architecture anchors

| Source | How it was used |
| --- | --- |
| [StepFun Step 3.7 Flash model card](https://huggingface.co/stepfun-ai/Step-3.7-Flash) | Official release surface, model positioning, availability, license, and deployment context. |
| [StepFun Step 3.7 Flash GitHub repo](https://github.com/stepfun-ai/Step-3.7-Flash) | Official README and local deployment guidance, including supported backends and high-memory local-device framing. |
| [StepFun Step 3.7 Flash launch post](https://static.stepfun.com/blog/step-3.7-flash/) | Agentic coding, tool-use, search, and workflow motivation for choosing SWE-bench-Live-style prompts as routing probes. |
| [NVIDIA NeMo Step 3.7 coverage](https://docs.nvidia.com/nemo/automodel/nightly/model-coverage/vlm/stepfun-ai/step-3-7.html) | Public architecture bridge: Step3p7 class, Step-3.5-derived language backbone, 45 layers, 288 experts, top-8 routing, and 256k context. |
| [NVIDIA NIM Step 3.7 model card](https://build.nvidia.com/stepfun-ai/step-3.7-flash/modelcard) | Independent deployment and architecture framing, including the agentic/coding target and active-parameter view. |
| [Step 3.5 Flash technical report](https://arxiv.org/abs/2602.10604) | Architectural prior for the language path: dense/MoE layer split, routed experts, shared expert context, and top-k routing. |
| [Step-3 model-system co-design paper](https://arxiv.org/abs/2507.19427) | StepFun's broader model-system co-design context and decoding-cost motivation. |

### Memory and expert-loading prior art

| Source | How it was used |
| --- | --- |
| [Apple LLM in a Flash](https://arxiv.org/abs/2312.11514) | Main conceptual inspiration: use flash storage as part of the inference memory hierarchy and load only what is needed. |
| [FlashMoE cache-replacement paper](https://arxiv.org/abs/2601.17063) | Closest academic analogue for MoE offload/cache replacement: better-than-LRU/LFU expert reuse and SSD-backed edge constraints. |
| [Expert-routing phases paper](https://arxiv.org/abs/2604.04230) | Methodological support for tracing workload-specific expert usage instead of assuming expert activations are uniform or human-obvious. |
| [fMoE fine-grained expert offloading](https://arxiv.org/abs/2502.05370) | General prior art for inactive expert offload and fine-grained MoE serving. |
| [MOE-INFINITY](https://openreview.net/pdf/683ee20a5f0b1a7b8c437a03ec6b0961d677527f.pdf) | Broader personal-machine MoE inference context and expert-cache framing. |

### Apple Silicon and MLX ecosystem

| Source | How it was used |
| --- | --- |
| [Apple MLX](https://github.com/ml-explore/mlx) | Core array/runtime substrate for Apple Silicon execution. |
| [MLX documentation](https://ml-explore.github.io/mlx/) | Unified-memory and lazy-computation model context. |
| [mlx-lm](https://github.com/ml-explore/mlx-lm) | Reference implementation context for MLX language-model handling, quantization conventions, and large-model workflows. |
| [mlx-vlm](https://github.com/Blaizzy/mlx-vlm) | VLM-side Apple Silicon context and useful reference surface for model conversion/quantization patterns. |

### Quantization and deployment context

| Source | How it was used |
| --- | --- |
| [StepFun official GGUF card](https://huggingface.co/stepfun-ai/Step-3.7-Flash-GGUF) | Public quant-size comparison: Q8_0 around 209 GB, showing why whole-model q8 does not fit the 96 GiB target. |
| [mudler Step 3.7 Flash APEX GGUF](https://huggingface.co/mudler/Step-3.7-Flash-APEX-GGUF) | Third-party systems intuition on mixed precision and Step-3.7/Step-3.5 GGUF mapping. Not treated as primary architecture authority. |
| [vLLM StepFun recipes](https://recipes.vllm.ai/stepfun-ai) | Serving ecosystem context: expert-parallel / FP8/NVFP4-style deployment direction rather than q8 expert-granular lazy loading. |
| [osmAPI Step 3.7 Flash MXFP4 MLX](https://huggingface.co/osmapi/Step-3.7-Flash-MXFP4-mlx) | Live MLX quant artifact produced alongside the research. |
| [osmAPI Step 3.7 Flash OptiQ 3.7bpw MLX](https://huggingface.co/osmapi/Step-3.7-Flash-OptiQ-3.7bpw-mlx) | Live mixed-precision MLX quant artifact produced alongside the research. |

### Routing probes and community leads

| Source | How it was used |
| --- | --- |
| [microsoft/SWE-bench-Live](https://github.com/microsoft/SWE-bench-Live) | Prompt source for coding-agent routing traces. Used as a systems probe, not a quality benchmark. |
| [anemll-flash-mlx discussion](https://www.reddit.com/r/LocalLLM/comments/1s81tjd/anemllflashmlx_simple_toolkit_to_speed_up/) | Community prior for MLX-side slot-bank thinking, hit/miss separation, and SSD streaming on misses. |
| [ANEMLL Flash-MoE ecosystem](https://www.anemll.com/) | Adjacent Apple Silicon Flash-MoE ecosystem and terminology context. |
| [MLX-Flash](https://pypi.org/project/mlx-flash/) | Adjacent MLX expert streaming / caching package. Treated as prior-art context, not as a dependency. |
| [LocalLLaMA Step 3.7 thread](https://www.reddit.com/r/LocalLLaMA/comments/1tqloii/stepfun_37_flash/) | Early community deployment expectations and memory arithmetic. |
| [LocalLLaMA experts-first / hot-cache thread](https://www.reddit.com/r/LocalLLaMA/comments/1tknbzh/experts_first_llamacpp/) | Community signal on expert hot-cache / task-profile ideas. |
| [Step 3.5 architecture summary on X](https://x.com/TheAhmadOsman/status/2018173810827047231) | Discovery lead only. The actual architecture claims were cross-checked against StepFun/NVIDIA/arXiv sources. |

## Why This Is Hard

Step 3.7 Flash is exactly the kind of model that makes local inference exciting and slightly inconvenient.

The official model card positions it as a high-throughput sparse MoE model for agentic workflows, with a 256k context window, multimodal support, and roughly 11B active parameters per token. NVIDIA's public model notes describe the language module as 45 layers with 288 experts and 8 activated experts per token.

That architecture is friendly to selective compute. But a q8 local checkpoint is still large:

| Quantity | Value |
| --- | ---: |
| Decoder layers | 45 |
| MoE layers | 42, layers 3-44 |
| Routed experts per MoE layer | 288 |
| Routed experts total | 12,096 |
| Router top-k | 8 |
| Dynamic active slots per token pass | 336 |
| Resident text core estimate | 6.63 GiB |
| All routed experts q8 estimate | 188.26 GiB |
| Total indexed q8 tensor set | 199.74 GiB |

If the whole q8 model is treated as resident, the experiment is over before it begins. The useful question is narrower:

Can we keep only the core, the current active experts, and a small protected standby floor in RAM, while leaving most experts on disk until the router demands them?

![Step 3.7 Flash q8 architecture and residency categories](https://huggingface.co/datasets/junafinity/step37-flash-lazy-loading-article-assets/resolve/main/assets/step37-architecture.png)

## The Residency Categories

We ended up using four main categories.

| Category | Meaning | Residency behavior |
| --- | --- | --- |
| Active | The router selected this expert for the current token or micro-batch. | Must be available immediately. Dynamic, not permanent. |
| Up Next | Experts predicted from near-future layer priors and recent routing transitions. | Prefetch candidates when memory pressure allows. |
| Backup / Standby | A durable hot floor of experts with strong trace evidence. | Protected from eviction. In the final proof: 514 experts, 8.59 GiB. |
| Inactive | All other routed experts. | Stay on disk unless the router asks for them. |

The important correction is that "agentic coding layers" did not mean removing decoder layers. Every decoder layer still runs. What we carved out was an expert-residency policy from coding-agent prompts: which experts should be protected, which are worth prefetching, and which should remain cold.

For this, we used random coding-inference questions from [microsoft/SWE-bench-Live](https://github.com/microsoft/SWE-bench-Live). The prompts are useful because they resemble real agentic coding work: issue text, repository context, multi-file reasoning, and patch-planning behavior. They are not a full quality benchmark here. They are a routing probe.

## The Flash Load Runtime

The runtime has three practical pieces.

First, a JSONL index maps every routed expert to exact safetensors byte ranges. Each row knows the layer, expert id, shard, tensor names, byte offsets, byte lengths, q8 format, and role labels. That lets the runtime materialize a single expert pack without scanning the full checkpoint.

Second, an MLX policy cache admits expert packs by category. Backup/Standby experts are protected. Warm probation experts can be evicted. Up Next experts are admitted only if the cache policy says the memory budget can afford them.

Third, context memory is tracked separately from model memory. The user-facing budget was 96 GiB for model residency and 2 GiB for context/KV. For this bounded proof, q8 affine KV used only 7,050,240 bytes. For long context, the estimator recommends more aggressive compression: q8 KV under 2 GiB at 65k, q4 KV around 128k, and q2-style emergency compression for 256k. A TQ3-like 256k estimate was about 2.45 GiB, so it did not meet the strict 2 GiB target by itself.

![Smart lazy-loading flow](https://huggingface.co/datasets/junafinity/step37-flash-lazy-loading-article-assets/resolve/main/assets/step37-lazy-loading-flow.png)

## Where "LLM in a Flash" Fits

Apple's LLM in a Flash paper studies inference when model parameters exceed available DRAM. The paper's core direction is to make flash storage part of the inference plan: predict what will be needed, load it efficiently, and avoid moving unnecessary weights.

Our experiment borrows that philosophy but changes the unit of movement.

In this Step 3.7 Flash q8 Flash Load runtime, the natural unit is a routed expert. Every MoE layer has 288 candidates, but only top-8 are active for a token. Instead of asking "can we load the whole model?", the runtime asks:

1. Which expert did the router select right now?
2. Is it already Active or Backup/Standby?
3. If not, is it in Up Next or Inactive?
4. Can we load only that expert slice by byte offset?
5. Which warm probation slice can be evicted without touching the protected Backup floor?

That is the whole idea in small form: flash-aware selective residency, adapted to a routed MoE.

## Clean Proof Setup

The final proof used:

| Item | Value |
| --- | --- |
| Machine | MacBook Pro, M3 Max, 128 GiB unified memory |
| Runtime | Python 3.14.3, MLX 0.31.2 |
| Model path | local Step 3.7 Flash q8 MLX checkpoint |
| Prompt source | SWE-bench-Live prompt `thlorenz__doctoc-329` |
| Prompt tokens | 64 |
| Decode steps | 8 |
| KV codec | q8 affine KV |
| Model ceiling | 96 GiB |
| Context/KV ceiling | 2 GiB |
| Hard expert-cache budget | 24 GiB |
| Backup/Standby floor | 514 q8 experts |

The clean-baseline gate mattered. Earlier attempts were polluted by macOS file-backed cache from large safetensors reads, which made under-100 GiB claims ambiguous. The final proof required a clean baseline before launching:

- baseline clean: true
- baseline used memory: 14.48 GiB
- baseline file-backed memory: 25.49 GiB
- free plus speculative memory: 113.52 GiB

![Memory budget from target to proof](https://huggingface.co/datasets/junafinity/step37-flash-lazy-loading-article-assets/resolve/main/assets/step37-memory-budget.png)

## Results

The full indexed-manifest run completed successfully.

| Metric | Value |
| --- | ---: |
| Exit status | 0 |
| Prompt tokens | 64 |
| Decode steps | 8 |
| Peak `top` memory used | 42.00 GiB |
| Peak `vm_stat` used | 43.52 GiB |
| Peak process RSS | 29.43 GiB |
| Estimated model peak | 38.63 GiB |
| q8 KV/context bytes | 7,050,240 bytes |
| Fits 96 GiB model ceiling | true |
| Fits 2 GiB context ceiling | true |
| Policy cache peak | 25,769,410,560 bytes, about 24.00 GiB |
| Loaded policy-cache slices | 1,542 |
| Indexed expert loads | 6,916 |
| Indexed expert load time | 41.49 s |
| Policy evictions | 5,374 |
| Backup/Standby loaded | 514 / 514 |
| Backup/Standby missing | 0 |
| Backup/Standby evicted | 0 |
| TTFT | 41.96 s |
| Prefill throughput | 1.65 tok/s |
| Decode throughput | 0.693 tok/s |
| End-to-end sampled throughput | 0.168 tok/s |

![Clean indexed proof metrics](https://huggingface.co/datasets/junafinity/step37-flash-lazy-loading-article-assets/resolve/main/assets/step37-proof-metrics.png)

The headline is not "this is fast." It is:

We executed the q8 model path under 100 GiB live memory including context, without fully loading the 199.74 GiB q8 tensor set, and without evicting the 514-expert Backup/Standby floor.

That gives us a defensible base for the next phase: performance.

## What Failed First

The best part of this work is that the failures were informative.

The first under-100 GiB attempts could run bounded prompts, but macOS file-backed memory made the proof messy. A run could appear to fit by process RSS while the system had quietly filled much of unified memory with cached checkpoint pages. That is not a good academic claim.

Then a full protected-Backup run kept the idea alive but exceeded the live-memory line and evicted Backup entries. That became the reason to add:

- clean-baseline gating
- no-cache core and expert reads
- token-scoped Active protection
- exact indexed expert loading
- explicit Backup/Standby eviction accounting

![Failures became the roadmap](https://huggingface.co/datasets/junafinity/step37-flash-lazy-loading-article-assets/resolve/main/assets/step37-roadmap.png)

The final indexed proof is the result of those negative runs rather than a straight line from idea to success.

## Why Decode Is Still Slow

The decode number was 0.693 tok/s. If you are used to LM Studio, llama.cpp, or hosted inference dashboards, that is the number closest to the familiar "tokens per second" readout.

The bottleneck is obvious in the trace: 6,916 indexed expert loads took 41.49 seconds. The runtime is memory-efficient, but it is still cold-load-heavy. This is the price of proving expert-granular paging before optimizing the hot path.

The path toward 10 tok/s on this Mac is not a single flag. It likely needs:

- fewer decode-time cold loads through a larger and better hotset
- batched expert-pack reads
- fused or grouped MoE expert execution in MLX
- stronger Up Next prediction without creating churn
- mixed precision for cold or low-impact experts
- a speculative or MTP path after the base runtime is stable

The current result is a fit proof. The next result should be a speed proof.

## Live Quant Artifacts

The lazy-loading proof in this post used a local q8 affine MLX checkpoint. Alongside that research path, we published live MLX quant artifacts for broader experimentation:

| Repo | Status | Notes |
| --- | --- | --- |
| [osmapi/Step-3.7-Flash-MXFP4-mlx](https://huggingface.co/osmapi/Step-3.7-Flash-MXFP4-mlx) | public | MXFP4 / microscaling FP4 MLX artifact for Apple Silicon experiments. |
| [osmapi/Step-3.7-Flash-OptiQ-3.7bpw-mlx](https://huggingface.co/osmapi/Step-3.7-Flash-OptiQ-3.7bpw-mlx) | public | Mixed-precision OptiQ 3.7 bpw MLX artifact. |
| Step 3.7 Flash q8 affine MLX | local research artifact | Used for the indexed q8 lazy-loading proof; public large-blob release was still being staged at the time of this post. |

The important distinction is that this article's under-100 GiB proof is for the q8 Flash Load runtime, not a claim that the public MXFP4 or OptiQ repos already implement the same smart paging policy. Those repos are live quant artifacts. Flash Load is the research runtime that will inform the next release path.

## What This Means

This experiment suggests that sparse MoE models should not be judged only by total parameter count when we talk about local inference. The routing structure is an opportunity. If the runtime can cheaply answer "which expert do I need now?" and "where exactly is that expert on disk?", then storage, memory, and compute can be coordinated more intelligently.

Step 3.7 Flash is a good stress case because it is big enough to force the issue, sparse enough to reward selectivity, and agentic enough that coding prompts produce meaningful routing traces.

The academic claim we can safely make today is modest but useful:

A q8 Step 3.7 Flash language-path inference can be executed on an M3 Max MacBook Pro under a 96 GiB model-memory ceiling and 2 GiB context ceiling by using expert-granular indexed lazy loading, protected Standby residency, and compressed KV accounting.

The engineering claim is sharper:

The runtime no longer needs to choose between "load all q8 experts" and "do not run the model." Flash Load can keep a small protected floor in RAM and fetch the rare experts it needs.

## Limitations

- This is a bounded smoke proof: 64 prompt tokens and 8 decode steps.
- Vision and MTP/speculative layers were excluded from this proof.
- The prompt set was used for routing and systems evidence, not for a full quality benchmark.
- Decode throughput is still low because cold expert loads dominate.
- The q8 checkpoint used for the proof was local; public q8 large-blob release work was still in progress.
- A production runtime still needs broader prompt coverage, long-context runs, quality comparisons, and deeper MLX kernel optimization.

## Acknowledgements

Thank you to the [osmAPI](https://osmapi.com) Research Team and the [TERV.Pro](https://terv.pro) Student Research Team for the research loop, infrastructure patience, quant publication work, and the many small operational decisions that make this kind of local systems experiment possible.

Thank you to [StepFun](https://huggingface.co/stepfun-ai/Step-3.7-Flash) for releasing Step 3.7 Flash with open weights and enough ecosystem support to make local experiments plausible.

Thank you to Apple Machine Learning Research and the [MLX](https://github.com/ml-explore/mlx) team. This work leans directly on MLX's Apple Silicon-friendly execution model and is conceptually inspired by [LLM in a Flash](https://arxiv.org/abs/2312.11514).

Thank you to [Microsoft SWE-bench-Live](https://github.com/microsoft/SWE-bench-Live) for the live coding-agent prompt source used to probe routing behavior.

Thank you to the broader local-inference community working on Flash-MoE, MLX-Flash, llama.cpp MoE offload, expert hot caches, and SSD expert streaming. This work is better because those experiments made the design space visible.

Related references and ecosystem links:

Architecture and model sources:

- StepFun official model: [stepfun-ai/Step-3.7-Flash](https://huggingface.co/stepfun-ai/Step-3.7-Flash)
- StepFun GitHub release repo: [stepfun-ai/Step-3.7-Flash](https://github.com/stepfun-ai/Step-3.7-Flash)
- StepFun launch post: [Step 3.7 Flash](https://static.stepfun.com/blog/step-3.7-flash/)
- NVIDIA public Step 3.7 notes: [NVIDIA NIM model card](https://build.nvidia.com/stepfun-ai/step-3.7-flash/modelcard)
- NVIDIA NeMo Step 3.7 coverage: [Step-3.7-Flash](https://docs.nvidia.com/nemo/automodel/nightly/model-coverage/vlm/stepfun-ai/step-3-7.html)
- Step 3.5 Flash technical report: [arXiv:2602.10604](https://arxiv.org/abs/2602.10604)
- Step-3 model-system co-design paper: [arXiv:2507.19427](https://arxiv.org/abs/2507.19427)

Memory and expert-loading prior art:

- Apple paper: [LLM in a Flash](https://arxiv.org/abs/2312.11514)
- FlashMoE cache-replacement paper: [arXiv:2601.17063](https://arxiv.org/abs/2601.17063)
- fMoE fine-grained expert offloading: [arXiv:2502.05370](https://arxiv.org/abs/2502.05370)
- Expert routing phases paper: [arXiv:2604.04230](https://arxiv.org/abs/2604.04230)
- MOE-INFINITY: [OpenReview PDF](https://openreview.net/pdf/683ee20a5f0b1a7b8c437a03ec6b0961d677527f.pdf)

Apple Silicon, quant, and deployment context:

- Apple MLX: [ml-explore/mlx](https://github.com/ml-explore/mlx)
- MLX documentation: [ml-explore.github.io/mlx](https://ml-explore.github.io/mlx/)
- mlx-lm: [ml-explore/mlx-lm](https://github.com/ml-explore/mlx-lm)
- mlx-vlm: [Blaizzy/mlx-vlm](https://github.com/Blaizzy/mlx-vlm)
- StepFun official GGUF card: [Step-3.7-Flash-GGUF](https://huggingface.co/stepfun-ai/Step-3.7-Flash-GGUF)
- mudler Step 3.7 Flash APEX GGUF: [Step-3.7-Flash-APEX-GGUF](https://huggingface.co/mudler/Step-3.7-Flash-APEX-GGUF)
- vLLM StepFun recipes: [recipes.vllm.ai/stepfun-ai](https://recipes.vllm.ai/stepfun-ai)
- Live MXFP4 MLX quant: [osmapi/Step-3.7-Flash-MXFP4-mlx](https://huggingface.co/osmapi/Step-3.7-Flash-MXFP4-mlx)
- Live OptiQ MLX quant: [osmapi/Step-3.7-Flash-OptiQ-3.7bpw-mlx](https://huggingface.co/osmapi/Step-3.7-Flash-OptiQ-3.7bpw-mlx)

Prompt and community research leads:

- Microsoft SWE-bench-Live: [microsoft/SWE-bench-Live](https://github.com/microsoft/SWE-bench-Live)
- ANEMLL Flash-MoE ecosystem: [anemll.com](https://www.anemll.com/)
- anemll-flash-mlx: [Anemll/anemll-flash-mlx](https://github.com/Anemll/anemll-flash-mlx)
- MLX-Flash package: [mlx-flash on PyPI](https://pypi.org/project/mlx-flash/)
- LocalLLaMA Step 3.7 thread: [StepFun 3.7 Flash discussion](https://www.reddit.com/r/LocalLLaMA/comments/1tqloii/stepfun_37_flash/)
- LocalLLaMA experts-first / hot-cache thread: [experts-first llama.cpp discussion](https://www.reddit.com/r/LocalLLaMA/comments/1tknbzh/experts_first_llamacpp/)
- anemll-flash-mlx discussion: [LocalLLM thread](https://www.reddit.com/r/LocalLLM/comments/1s81tjd/anemllflashmlx_simple_toolkit_to_speed_up/)
- Step 3.5 architecture summary on X: [discovery lead](https://x.com/TheAhmadOsman/status/2018173810827047231)

Tags for sharing: Flash Load, Apple Silicon, MLX, LLM in a Flash, StepFun, Step 3.7 Flash, osmAPI, Terv, SWE-bench-Live, MoE, quantization, lazy loading, expert streaming, local inference.