Add Step 3.7 Flash lazy-loading article assets

README.md

@@ -0,0 +1,24 @@
+# Step 3.7 Flash Lazy Loading Article Assets
+
+This dataset hosts static diagrams and the Markdown source for the Hugging Face article:
+
+Smart Lazy Loading Step 3.7 Flash q8 on Apple Silicon
+
+The diagrams explain the expert-granular lazy-loading runtime used in a local research proof on an M3 Max MacBook Pro with a 96 GiB model-memory ceiling and a 2 GiB context/KV ceiling.
+
+Primary article source:
+
+- `step37_lazy_loading_hf_article.md`
+
+Figures:
+
+- `assets/step37-architecture.png`
+- `assets/step37-lazy-loading-flow.png`
+- `assets/step37-memory-budget.png`
+- `assets/step37-proof-metrics.png`
+- `assets/step37-roadmap.png`
+
+Related live MLX quant repos:
+
+- https://huggingface.co/osmapi/Step-3.7-Flash-MXFP4-mlx
+- https://huggingface.co/osmapi/Step-3.7-Flash-OptiQ-3.7bpw-mlx

build_step37_blog_assets.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+"""Build static diagrams for the Step 3.7 Flash lazy-loading article."""
+
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+
+ROOT = Path(__file__).resolve().parent
+ASSETS = ROOT / "assets"
+ASSETS.mkdir(parents=True, exist_ok=True)
+
+FONT = "/System/Library/Fonts/Supplemental/Arial.ttf"
+BOLD = "/System/Library/Fonts/Supplemental/Arial Bold.ttf"
+MONO = "/System/Library/Fonts/SFNSMono.ttf"
+
+
+def font(size: int, bold: bool = False, mono: bool = False) -> ImageFont.FreeTypeFont:
+    path = MONO if mono else (BOLD if bold else FONT)
+    return ImageFont.truetype(path, size=size)
+
+
+def text(draw: ImageDraw.ImageDraw, xy: tuple[int, int], value: str, size: int = 28, fill="#13202c", bold: bool = False, mono: bool = False) -> None:
+    draw.text(xy, value, font=font(size, bold=bold, mono=mono), fill=fill)
+
+
+def wrapped(draw: ImageDraw.ImageDraw, xy: tuple[int, int], value: str, width: int, size: int = 24, fill="#334155", bold: bool = False, line_gap: int = 8) -> int:
+    avg = max(size * 0.52, 1)
+    chars = max(int(width / avg), 8)
+    y = xy[1]
+    for line in textwrap.wrap(value, width=chars):
+        draw.text((xy[0], y), line, font=font(size, bold=bold), fill=fill)
+        y += size + line_gap
+    return y
+
+
+def card(
+    draw: ImageDraw.ImageDraw,
+    box: tuple[int, int, int, int],
+    title: str,
+    body: list[str],
+    fill: str,
+    outline: str,
+    accent: str | None = None,
+    title_size: int = 30,
+    body_size: int = 22,
+) -> None:
+    draw.rounded_rectangle(box, radius=26, fill=fill, outline=outline, width=3)
+    x1, y1, x2, _ = box
+    if accent:
+        draw.rounded_rectangle((x1, y1, x1 + 16, box[3]), radius=18, fill=accent)
+    text(draw, (x1 + 34, y1 + 26), title, size=title_size, bold=True, fill="#0f172a")
+    y = y1 + 68
+    for line in body:
+        y = wrapped(draw, (x1 + 34, y), line, width=x2 - x1 - 68, size=body_size, fill="#334155", line_gap=5)
+        y += 2
+
+
+def arrow(draw: ImageDraw.ImageDraw, start: tuple[int, int], end: tuple[int, int], fill="#475569", width=5) -> None:
+    draw.line((start, end), fill=fill, width=width)
+    sx, sy = start
+    ex, ey = end
+    if abs(ex - sx) >= abs(ey - sy):
+        sign = 1 if ex > sx else -1
+        pts = [(ex, ey), (ex - sign * 18, ey - 10), (ex - sign * 18, ey + 10)]
+    else:
+        sign = 1 if ey > sy else -1
+        pts = [(ex, ey), (ex - 10, ey - sign * 18), (ex + 10, ey - sign * 18)]
+    draw.polygon(pts, fill=fill)
+
+
+def canvas(title: str, subtitle: str) -> tuple[Image.Image, ImageDraw.ImageDraw]:
+    im = Image.new("RGB", (1800, 1100), "#f8fafc")
+    draw = ImageDraw.Draw(im)
+    draw.rectangle((0, 0, 1800, 140), fill="#0f172a")
+    text(draw, (64, 34), title, size=48, fill="#ffffff", bold=True)
+    text(draw, (66, 92), subtitle, size=24, fill="#cbd5e1")
+    return im, draw
+
+
+def architecture() -> None:
+    im, draw = canvas(
+        "Step 3.7 Flash q8: model shape and residency target",
+        "The runtime treats routed experts as the pageable unit, not the whole model.",
+    )
+    card(draw, (70, 195, 470, 470), "Dense entry", [
+        "Tokenizer, embeddings, norms, attention blocks, and the first dense decoder layers remain resident.",
+        "Measured q8 text core estimate: 6.63 GiB.",
+    ], "#e0f2fe", "#38bdf8", "#0284c7", body_size=21)
+    card(draw, (535, 195, 930, 470), "MoE stack", [
+        "45 decoder layers total. Layers 3-44 are routed MoE layers.",
+        "42 MoE layers x 288 routed experts = 12,096 expert slices.",
+    ], "#ecfeff", "#22d3ee", "#0891b2", body_size=21)
+    card(draw, (995, 195, 1395, 470), "Router", [
+        "Each MoE layer scores 288 experts.",
+        "Top-8 experts are selected per token or micro-batch.",
+    ], "#fef9c3", "#facc15", "#ca8a04", body_size=21)
+    card(draw, (1450, 195, 1730, 470), "Active compute", [
+        "Top-8 x 42 layers = 336 dynamic active slots.",
+        "Active is an event, not a permanent category.",
+    ], "#dcfce7", "#4ade80", "#16a34a", title_size=27, body_size=20)
+    arrow(draw, (470, 332), (535, 332))
+    arrow(draw, (930, 332), (995, 332))
+    arrow(draw, (1395, 332), (1450, 332))
+
+    card(draw, (90, 570, 430, 900), "Active", [
+        "Router-selected top-k for the current token.",
+        "336 possible layer-token slots in a full pass.",
+        "Must be available immediately.",
+    ], "#dcfce7", "#22c55e", "#16a34a", body_size=21)
+    card(draw, (500, 570, 840, 900), "Up Next", [
+        "672 bootstrap references.",
+        "Predicted near-future experts from routing priors and transitions.",
+        "Loaded only when free budget exists.",
+    ], "#fef3c7", "#f59e0b", "#d97706", body_size=21)
+    card(draw, (910, 570, 1250, 900), "Backup / Standby", [
+        "514 protected experts.",
+        "8.59 GB q8 residency floor.",
+        "Never evicted in the clean indexed proof.",
+    ], "#ede9fe", "#8b5cf6", "#7c3aed", body_size=21)
+    card(draw, (1320, 570, 1660, 900), "Inactive", [
+        "11,582 experts remain on disk.",
+        "193.55 GB of q8 slices not resident by default.",
+        "Rare router demand triggers exact slice load.",
+    ], "#f1f5f9", "#94a3b8", "#64748b", body_size=21)
+    text(draw, (92, 970), "Measured target: 96 GiB model ceiling + 2 GiB context/KV ceiling on a 128 GiB M3 Max MacBook Pro.", size=30, bold=True)
+    im.save(ASSETS / "step37-architecture.png", quality=95)
+
+
+def flow() -> None:
+    im, draw = canvas(
+        "Smart lazy-loading flow",
+        "An indexed safetensors map turns each routed expert into an addressable q8 page.",
+    )
+    boxes = [
+        ((80, 215, 390, 410), "SWE-bench-Live prompt", "Random coding issue prefix; 64 tokens in the full proof."),
+        ((470, 215, 780, 410), "Resident core", "Embeddings, attention, dense layers, norms, and router weights."),
+        ((860, 215, 1170, 410), "Router top-k", "Choose top-8 experts per MoE layer."),
+        ((1250, 215, 1640, 410), "MLX expert forward", "Load exact q8 expert pack; run gate/up/down projections."),
+    ]
+    for box, title, body in boxes:
+        card(draw, box, title, [body], "#ffffff", "#cbd5e1", "#0ea5e9", title_size=29, body_size=22)
+    for a, b in [((390, 312), (470, 312)), ((780, 312), (860, 312)), ((1170, 312), (1250, 312))]:
+        arrow(draw, a, b)
+
+    card(draw, (180, 520, 610, 790), "Indexed q8 slice loader", [
+        "JSONL index stores layer, expert, shard, tensor names, byte offsets, and byte lengths.",
+        "No-cache reads reduce macOS file-backed memory pollution.",
+    ], "#f8fafc", "#94a3b8", "#475569")
+    card(draw, (690, 520, 1120, 790), "Policy cache", [
+        "24 GiB hard expert-cache budget in the final indexed run.",
+        "514 Backup/Standby experts are protected; warm probation experts are evictable.",
+    ], "#f8fafc", "#94a3b8", "#475569")
+    card(draw, (1200, 520, 1625, 790), "q8 KV/context cache", [
+        "Separate 2 GiB context ceiling.",
+        "Full proof used q8 affine KV: 7,050,240 bytes for the bounded sample.",
+    ], "#f8fafc", "#94a3b8", "#475569")
+    arrow(draw, (1015, 410), (395, 520), fill="#64748b")
+    arrow(draw, (610, 655), (690, 655), fill="#64748b")
+    arrow(draw, (1120, 655), (1200, 655), fill="#64748b")
+    arrow(draw, (1415, 520), (1415, 410), fill="#64748b")
+
+    draw.rounded_rectangle((110, 870, 1690, 1030), radius=28, fill="#0f172a")
+    text(draw, (150, 905), "Core idea", size=34, fill="#ffffff", bold=True)
+    wrapped(draw, (150, 952), "Instead of loading a 199.74 GiB q8 tensor set, keep the core and protected floor resident, then fetch only the expert slices demanded by the router.", width=1500, size=24, fill="#dbeafe", line_gap=4)
+    im.save(ASSETS / "step37-lazy-loading-flow.png", quality=95)
+
+
+def memory_budget() -> None:
+    im, draw = canvas(
+        "Memory budget from target to proof",
+        "The proof tracked model memory, context memory, process RSS, and macOS platform memory.",
+    )
+    left, top, width, height = 170, 300, 1320, 100
+    segments = [
+        ("resident core", 6.63, "#38bdf8"),
+        ("policy cache peak", 24.00, "#8b5cf6"),
+        ("other model path", 8.00, "#22c55e"),
+        ("remaining slack", 57.37, "#e2e8f0"),
+    ]
+    x = left
+    for label, val, color in segments:
+        w = int(width * val / 96.0)
+        draw.rectangle((x, top, x + w, top + height), fill=color)
+        if w > 130:
+            text(draw, (x + 14, top + 32), f"{label}\\n{val:.2f} GiB", size=20, fill="#0f172a", bold=True)
+        x += w
+    draw.rectangle((left, top, left + width, top + height), outline="#0f172a", width=3)
+    text(draw, (left, top - 54), "96 GiB model ceiling", size=34, bold=True)
+    text(draw, (left + width + 24, top + 32), "Target", size=30, bold=True)
+
+    left2, top2, width2, height2 = 170, 550, 1320, 82
+    draw.rectangle((left2, top2, left2 + width2, top2 + height2), fill="#e2e8f0", outline="#0f172a", width=3)
+    used = int(width2 * 0.00657 / 2.0)
+    draw.rectangle((left2, top2, left2 + max(used, 7), top2 + height2), fill="#0ea5e9")
+    text(draw, (left2, top2 - 52), "2 GiB context/KV ceiling", size=34, bold=True)
+    text(draw, (left2 + 24, top2 + 24), "q8 affine KV in proof: 7.05 MB", size=24, bold=True)
+
+    metrics = [
+        ("external top peak", "42.00 GiB"),
+        ("vm_stat used peak", "43.52 GiB"),
+        ("process RSS peak", "29.43 GiB"),
+        ("estimated model peak", "38.63 GiB"),
+    ]
+    x = 180
+    for title, value in metrics:
+        draw.rounded_rectangle((x, 760, x + 330, 930), radius=26, fill="#ffffff", outline="#cbd5e1", width=3)
+        text(draw, (x + 24, 795), value, size=38, bold=True, fill="#0f172a")
+        wrapped(draw, (x + 24, 850), title, width=280, size=24, fill="#475569")
+        x += 385
+    im.save(ASSETS / "step37-memory-budget.png", quality=95)
+
+
+def results() -> None:
+    im, draw = canvas(
+        "Clean indexed proof metrics",
+        "Bounded q8 run: 64 prompt tokens, 8 decode steps, q8 KV, Step 3.7 Flash on MLX.",
+    )
+    cards = [
+        ("Max platform used", "43.52 GiB", "vm_stat used; top reported 42.0 GiB"),
+        ("Process RSS", "29.43 GiB", "Peak Python worker resident set"),
+        ("TTFT", "41.96 s", "Setup plus prefill to first sampled token"),
+        ("Prefill", "1.65 tok/s", "Prompt ingestion throughput"),
+        ("Decode", "0.693 tok/s", "Closest number to chat-app tok/s"),
+        ("q8 KV", "7.05 MB", "Context cache for this bounded proof"),
+        ("Indexed loads", "6,916", "Exact q8 expert-slice loads"),
+        ("Backup kept", "514/514", "No Backup/Standby misses or evictions"),
+    ]
+    for i, (title, value, body) in enumerate(cards):
+        col = i % 4
+        row = i // 4
+        x = 95 + col * 425
+        y = 220 + row * 350
+        draw.rounded_rectangle((x, y, x + 360, y + 260), radius=30, fill="#ffffff", outline="#cbd5e1", width=3)
+        text(draw, (x + 28, y + 34), value, size=46, bold=True, fill="#0f172a")
+        text(draw, (x + 30, y + 100), title, size=28, bold=True, fill="#334155")
+        wrapped(draw, (x + 30, y + 145), body, width=300, size=22, fill="#64748b")
+    draw.rounded_rectangle((145, 930, 1655, 1010), radius=22, fill="#ecfeff", outline="#22d3ee", width=3)
+    text(draw, (180, 952), "Interpretation: memory proof succeeded; throughput is research-runtime slow because cold indexed expert loads still dominate decode.", size=26, bold=True, fill="#164e63")
+    im.save(ASSETS / "step37-proof-metrics.png", quality=95)
+
+
+def roadmap() -> None:
+    im, draw = canvas(
+        "Failures became the roadmap",
+        "Each negative run turned into an engineering constraint for the final indexed proof.",
+    )
+    steps = [
+        ("Dirty file cache", "macOS file-backed pages made earlier under-100 claims indefensible."),
+        ("Clean baseline gate", "Require low used memory, low file-backed memory, and enough free+speculative memory before proof."),
+        ("No-cache slice reads", "Avoid polluting platform memory with large safetensors file cache pages."),
+        ("Indexed expert map", "Load exact q8 experts by byte offset instead of scanning tensor dictionaries."),
+        ("Protected Backup floor", "Keep 514 Standby experts resident while evicting warm probation entries."),
+        ("Next speed target", "Batch/fuse MoE loads and reduce cold-loads before chasing 10 tok/s."),
+    ]
+    y = 210
+    for i, (title, body) in enumerate(steps):
+        x = 130 if i % 2 == 0 else 950
+        color = "#fee2e2" if i == 0 else "#ffffff"
+        outline = "#ef4444" if i == 0 else "#cbd5e1"
+        card(draw, (x, y, x + 650, y + 150), title, [body], color, outline, "#0ea5e9")
+        if i < len(steps) - 1:
+            if i % 2 == 0:
+                arrow(draw, (780, y + 75), (950, y + 75), fill="#64748b")
+            else:
+                arrow(draw, (950, y + 150), (780, y + 225), fill="#64748b")
+                y += 225
+    im.save(ASSETS / "step37-roadmap.png", quality=95)
+
+
+def main() -> None:
+    architecture()
+    flow()
+    memory_budget()
+    results()
+    roadmap()
+    print(f"Wrote diagrams to {ASSETS}")
+
+
+if __name__ == "__main__":
+    main()

step37_lazy_loading_hf_article.md

@@ -0,0 +1,255 @@
+# Smart Lazy Loading Step 3.7 Flash q8 on Apple Silicon
+
+Authors: Arjun Reddy, osmAPI Research Team, and Terv Team
+
+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.
+
+## TLDR
+
+- 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.
+- 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.
+
+## 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 Lazy-Loading 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 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 lazy-loading runtime, not a claim that the public MXFP4 or OptiQ repos already implement the same smart paging policy. Those repos are live quant artifacts. The lazy loader 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." It 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://huggingface.co/osmapi) team and the Terv 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.
+
+Related references and ecosystem links:
+
+- 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/)
+- Apple paper: [LLM in a Flash](https://arxiv.org/abs/2312.11514)
+- Apple MLX: [ml-explore/mlx](https://github.com/ml-explore/mlx)
+- Microsoft SWE-bench-Live: [microsoft/SWE-bench-Live](https://github.com/microsoft/SWE-bench-Live)
+- NVIDIA public Step 3.7 notes: [NVIDIA NIM model card](https://build.nvidia.com/stepfun-ai/step-3.7-flash/modelcard)
+
+Tags for sharing: Apple Silicon, MLX, LLM in a Flash, StepFun, Step 3.7 Flash, osmAPI, Terv, SWE-bench-Live, MoE, quantization, lazy loading, local inference.