Strata and hybrid expert execution

Current status

The installed Lemonade CPU-expert path has completed native functional qualification. The separate experimental Strata adapter has also completed an actual installed-application flow on the exact RegesCore 35B artifact, at 8,192 context, 1,792 MiB expert cache and eight total CPU participants. These are different execution paths. Each path has its own evidence; the Strata result does not qualify other artifacts or cache configurations.

The current engineering preview exposes an explicit Inference engine selector. Lemonade remains the fresh and legacy default. Selecting Strata in Load Lab changes a draft setting; the header, Chat and System identify the actual active engine. An unsupported or failed Strata load must remain an error rather than silently falling back to Lemonade.

The upstream Strata repository is architecture-specific. The isolated RegesCore experiment pins e88ee39d1d6be6e3364183af3b39b62a7ed6f211 and adds opt-in native MXFP4 kernels plus a guarded zero-MTP artifact check. It is a modified developer build, not an unmodified upstream release or a Lemonade recipe.

What the hybrid engine does

The qualified standalone qwen35moe path retains every expert. A bounded GPU cache holds selected resident experts; selected misses compute on CPU using RAM. The model’s router still selects its original top eight experts. Cache residency does not mean dropping nonresident experts, pruning weights or requantizing the file.

This path is RAM/GPU hybrid expert execution, not the Flash-Next path that streams experts from SSD. Upstream has several architecture-specific execution paths; the app supports only its explicitly admitted profile.

Exact initial artifact

The candidate is the existing single-file RegesCore-1.0-35B-MXFP4_MOE artifact:

Property	Initial profile
File bytes	21,670,492,576
SHA-256	404a19069f44227a251a50fce77fcebe6ce4e4babcc2984efa14ee4ae5ef9ee6
Architecture / tensors	qwen35moe / 733
Main blocks / hidden width	40 / 2,048
Routed experts / selected per token	256 / 8
Expert feed-forward width	512
Predictor tensors	None; MTP disabled

Metadata admits a candidate only. The host verifies the complete file hash before execution. A matching name, file size or broad model family is insufficient.

The standalone CUDA kernel tests compare actual encoding arithmetic against pinned GGML. They do not establish end-to-end answer-quality parity. The private helper reconstructs full text history using the artifact’s actual tokenizer and sandboxed Jinja template, then exchanges token IDs with the resident native engine. No external Python installation, cloud account or public HTTP service is part of this design.

Tested native controls

• Backend: NVIDIA CUDA, with the fixed All policy for non-routed GPU work. This does not mean full-model GPU residency.
• Exact context: 256–8,192 tokens, bounded further by artifact metadata. Switching from a 57,000-token Lemonade draft preserves 57000 and shows an error; it does not shorten the value automatically.
• GPU expert cache: 512–4,096 MiB in 256 MiB steps; the initial app default is 2,048 MiB.
• CPU threads: zero chooses up to eight total CPU participants; explicit values are two through the host’s logical-core limit. The calling thread counts toward that total.
• Maximum output: 1–4,096 tokens per response. An existing larger Lemonade value remains visible and invalid until changed explicitly; it is not reduced automatically.
• Runtime availability: a present bundled runtime is not an integrity or inference success badge. Strata uses a private bundled runtime; Lemonade’s backend-install buttons do not install it.

A controls-only check of the actual development Electron application passed at 1,440 and 1,024 pixels. It exercised exact input preservation, invalid bounds, metadata eligibility, active-engine versus selected-draft labeling, and Save/relaunch persistence. It loaded no model; it is not native inference evidence.

All changes require an explicit load or reload. Loading and Save preferences persist the corresponding options; editing a draft does not.

Memory admission

The Strata planner shows GPU weights/cache separately from its state and workspace reserve. Its reference envelope is 6.5 GiB non-cache GPU pressure at 8,192 context, plus the chosen expert cache, with a further 1.5 GiB free-GPU reserve. This is a calibrated gate for this narrow profile, not measured allocation for every request.

Host admission pressure conservatively includes the entire mapped file plus a 19,016,011,776-byte pinned expert arena. It is not simply the file’s remaining CPU-weight fraction. Available memory already excludes a currently loaded model’s allocations; unload explicitly before calculating a replacement. The gate never credits imaginary reclaimed memory or silently reduces context/cache.

Helper and adapter qualification

The private JSONL helper completed an actual 2,048 MiB-cache model flow: arithmetic answer 4, a second turn requiring the prior history, an explicit context-overflow error, cancellation, a fresh successful answer and unload. Its initial app profile retained 28 GPU expert slots per layer. That validates the helper/native-engine boundary. A separate installed Electron proof subsequently exercised the broker, renderer and native engine at the explicit 1,792 MiB profile.

At this checkpoint, 65 TypeScript tests and 18 private-helper regressions passed. Their scope includes closed option validation, output limits, engine ownership and shutdown/switch races, prompt reconstruction, UTF-8/reasoning streaming, recoverable overflow and cancellation. Unit/regression counts are not end-to-end inference or quality measurements.

The frozen private runtime manifest contains 121 files / 630,335,480 bytes, excluding model weights. Its SHA-256 is 70b2b4f9df97aa8dbe70c15dee058f3c3c168e60685f186fb82c7897aed28701; the helper source hash is d3323a32dbdfe1d7e4990c7aacf2955abdd332546fe00ce5c2b5fe4d4143543b. These identify the runtime resources used by the qualified installed candidate; they do not establish an application publisher signature. The native CUDA build initially targets the qualified sm89 GPU architecture.

What has been measured

A corrected standalone smoke on the RTX 4070 SUPER system used 8,192 context, eight total CPU threads and a requested 4 GiB cache. It retained 57 of 256 expert slots per layer, generated 162 tokens and ended with the answer 4. The native engine reported 25.2 decode tokens/s for that one warm-repeat smoke. Peak sampled process RSS was roughly 39.53 GiB and total GPU use reached 11,651 MiB.

This is not a fair comparison with LM Studio, a sustained-throughput result, a quality evaluation or a native-app result. The helper’s smaller initial 2 GiB profile has separate functional evidence. The first actual GUI attempt at that budget was correctly refused because current free-VRAM admission was about 8.3 GiB, below the 6.5 + 2 GiB envelope; no native model was launched. A subsequent explicit 1,792 MiB GUI-cache profile completed chat, a history-dependent turn, cancellation, recovery and history persistence. The subsequent installed Strata-and-metrics flow also passed at this explicit profile, including actual live/final DOM measurements, retention of the earlier response during another generation, and identical stats after saved-history reopening. A different first run used nine total threads and must not be mixed into the corrected eight-thread result.

Limits and release gates

The requested 35B BF16 pair is a separate 64.612 GiB split-set experiment, not supported by this initial adapter. The 397B family is also separate; no 397B load or performance on a 12 GiB consumer GPU follows from the 35B smoke.

The actual installed proof completed ordinary and history-dependent chat, correlated streaming, cancellation and recovery, exact applied context/cache/threads, unload, history relaunch and owned-process shutdown. The first arithmetic response reported 156 output tokens, 23 input tokens and roughly 10.306 decode tokens/s in that functional case. It is not a target, guarantee or controlled comparison. See the sanitized installed evidence. A single correct arithmetic answer is deliberately limited evidence. Use the comparison protocol before making any speed claim.