FastStrata v0.6.0

A long conversation comes back after the model was stopped. The FastStrata Gateway stops the model when its app
closes, at Stop and when it swaps the model, and the engine kept its conversations in RAM only, so the next prompt of
a long conversation was read from its first token. Now the engine keeps them on disk too, and its next start takes them
up: on the 6 GB test laptop the next turn of a 70K conversation after a restart started after 7.2 s where 83.0, of a
40K one after 5.5 s where 40.0. The ready-made engine of this release is a new file,
strata-poly-windows-x64-b2b4ecb4224540ea.zip (RTX 20 to RTX 50, CUDA 13.0).

• --conversation-disk DIR (step 17 of docs/OPTIMIZATION_LOG.md): after every answer the engine writes what its
  conversation cache holds to DIR in the background, up to --conversation-disk-mib (default 4096): a conversation of
  the whole 144K context takes about 2.0 GiB, a 40K one 0.81 GiB. A file that is not whole is dropped at the next start,
  and the files are only taken up by the same model file, engine and options. The answers are written as fast as
  without it, and the tokens after a restart are those without one. It costs the RAM of the conversation in the engine
  as soon as it has answered (0.44 GiB at 40K, 0.78 GiB at 70K), inside the conversation cache's budget.
• Setup writes --conversation-disk <the data folder>\conversations --conversation-disk-mib 4096 on NVIDIA where the
  conversation cache is on and the data folder's disk has 20 GB free. It needs this release's engine: with an older one
  setup leaves the option out and says so. An install updated with UPDATE.bat keeps its config: add
  "--conversation-disk", "C:\\path\\to\\PolyStrata-data\\conversations" to the args of strata-<model>.json.
• Without --conversation-disk the engine writes v0.5.0's tokens.

FastStrata v0.5.0

A new engine that reads prompts faster. On the 6 GB test laptop an agent's turn of 1,501 tokens after a 38K
conversation is read in 3.9 s where v0.4.0 took 6.4, and the agent benchmark's 35 prompts in 79.6 s where 108; the
answers are written as fast as before. The ready-made engine of this release is a new file,
strata-poly-windows-x64-f8247c52a4fa5516.zip (RTX 20 to RTX 50, CUDA 13.0).

• A layer's experts are copied to the card in pieces of 64 MiB (step 15 of docs/OPTIMIZATION_LOG.md), so the host's
  copy of one piece runs under the card's copy of the one before: the 1,501-token turn 6.4 -> 5.0 s, a fresh 37K
  prompt 36.1 -> 34.9 s, the same tokens as v0.4.0, 0.9 GiB less pinned memory. Nothing to switch on.
• --stage-next (step 15): a read of 1,024 tokens or more gets a second staging buffer the expert cache lends it, and
  the next layer's experts are copied while a layer runs: the 1,501-token turn 5.0 -> 3.9 s, the agent benchmark's
  prompts 90 -> 79.6 s; the answers move as between two runs without it. Setup writes it on one NVIDIA card with 5 GB
  of VRAM or more. It needs this release's engine: with an older one setup leaves the option out and says so. An
  install updated with UPDATE.bat keeps its config: add "--stage-next" to the args of strata-<model>.json.
• Without --stage-next the engine writes v0.4.0's tokens.

FastStrata v0.4.0

A new engine: while an answer is written, the VRAM that prompts are read through holds more of the model's experts.
On the 6 GB test laptop an agent's answers are written 3% faster; on a 4 GB card, where no expert fitted in VRAM
before, a third of them do now. The README says what a 4 GB card runs: which Qwen file, which context cache and how
long a context. The ready-made engine of this release is a new file,
strata-poly-windows-x64-5a009f5d29282ef6.zip (RTX 20 to RTX 50, CUDA 13.0).

• --lend-staging (step 13 of docs/OPTIMIZATION_LOG.md): while an answer is written, the 500 MiB staging buffer that
  prompt batches copy experts through holds cached experts, and it goes back before the next batch. On the 6 GB test
  laptop an agent's 35 answers were written at 85.0 and 83.9 tok/s where 82.1 and 82.0; on the laptop with 2 GiB held
  (a 4 GB card) a third of the experts came from VRAM where none did, 11 to 19% faster without guesses. The answers
  move as between two runs without it. Setup writes it on one NVIDIA card. It needs this release's engine: with an
  older one setup leaves the option out and says so. An install updated with UPDATE.bat keeps its config: add
  "--lend-staging" to the args of strata-<model>.json.
• STRATA_ROUTE_TRACE and STRATA_SWAP_HALF (step 12), tools for measuring the expert cache: a trace of the routing
  and of what the cache held, for a simulator of cache rules (in the working repository). No rule the simulator
  tried beat the engine's own by more than 3%, and tables of experts by kind of work (code, documents) did not help.
• README.md and README.pl.md: a section on a 4 GB card, measured on the 6 GB card with 2 GiB held: Q4 (UD-Q4_K_M)
  with the 8-bit context cache at 32K, Q3 (UD-Q3_K_M) up to 48K, which to take with 32 GB of RAM and with more, and
  what was not measured.
• Without the new options the engine writes v0.3.0's tokens.

FastStrata v0.3.0

A new engine: with LODESTAR on, a turn's prompt is read in 7.7 s where it took 19.3 (the user's own OpenCode session
replayed on the 6 GB test laptop, the ready-made engines of v0.2.0 and of this release). The ready-made engine of this
release is a new file, strata-poly-windows-x64-59a3ba3a4a47ac90.zip (RTX 20 to RTX 50, CUDA 13.0).

• --prompt-cache-message N (step 11 of docs/OPTIMIZATION_LOG.md): the engine also keeps a checkpoint where the
  prompt's last message begins. The gateway's LODESTAR frame ends every prompt and the next prompt leaves it out; the
  Qwen3.6 model's recurrent layers could only go back to an older checkpoint, so every turn read 11,541 tokens again
  on that session, and now 2,640. Without LODESTAR the time is the same (5.0 s a turn). Off unless given; setup writes
  --prompt-cache-message 2048 on NVIDIA.
• Without the option the engine takes every prompt up where v0.2.0's does and reads the same tokens.

FastStrata v0.2.0

The fixes from two independent code audits of v0.1.1 (the server's routes for the gateway, the check of Python's
installer, the tests the CI runs), and the context's cache named apart from the model's Q4 / Q3. The engine is the
same as in v0.1.0 and v0.1.1: this release carries the same ready-made
strata-poly-windows-x64-3ba1bf3a4bf413eb.zip.

• The context's memory (the attention cache) is named apart from the model's Q4 / Q3: setup's menu says "up to 144K
  context with an 8-bit cache", the context question says what the cache is, and the README explains the two.
• The server's /completion and /tokenize (what the gateway sends) refuse a web page of another site without an
  API key, as /v1/* does: before, any site open in the browser could have the model write on the PC's card.
• An engine error in the middle of a streamed /completion reaches the gateway as an error event and [DONE], no
  longer as a second HTTP response written into the stream; the API monitor shows /completion's answer and speed.
• The web app's pages cannot be shown in another site's frame (X-Frame-Options, frame-ancestors).
• Where setup downloads python.org's Python 3.12 installer (no Python and no winget), it runs it only with the
  pinned SHA-256; START-HERE.bat checks the same.
• The CI runs the server's tests too (every serve/test_*.py against the mock engine), and Dependabot looks at the
  pinned packages once a month.

FastStrata v0.1.1

Setup and the gateway, from the first installs on other PCs. The engine is the same as in v0.1.0: this release
carries the same ready-made strata-poly-windows-x64-3ba1bf3a4bf413eb.zip.

• The gateway, release 47f4cd8: a read of a file the gateway spilled reaches the model whole. Before, an 8 KB file
  was replaced by a preview, the spill file the preview pointed to was replaced by the same preview, and the model
  read it again until the loop breaker stopped it, never having seen the file.
• Setup asks whether the NVIDIA card shows the desktop, with what it found as the answer (Windows: the screens
  Windows lists for each graphics; Linux: /sys/class/drm; else nvidia-smi). Where it does, the safe context is 10%
  below the longest that fits (128K instead of 144K on a 6 GB card); the VRAM in use is no longer taken off the card.
• Step 2's first choice is called the safe one.
• The gateway needs Python 3.12 or newer: where the PC has none, setup now installs Python 3.12 for the user's
  account on Windows (asked; winget, else python.org's installer, no administrator) and tells Linux the command,
  where it used to leave the gateway out with a warning.
• An NVIDIA driver older than 580 that still runs the CUDA 12 engine is told that setup compiles the engine because
  of it, and how to update the driver.
• The answer length: asked with the context where the models are chosen by hand (8K, 16K or 32K; the safe one is the
  preset's own, Qwen3.6 16K and Ornith 8K), or --max-output N / MODEL=N; at most a quarter of the context. Setup
  keeps it in the model's run config, and the gateway and OpenCode's limit.output take it from there.
• Setup's tests pass on Linux too (the CI's Ubuntu job): three upstream tests took Windows for granted.
• README: the gateway for OpenCode up front; a section on AMD cards (FastStrata's speedups are for NVIDIA RTX;
  with an AMD card, upstream PolyStrata).

FastStrata v0.1.0

A 35B mixture-of-experts coding model for OpenCode on a gaming PC with a small graphics card: Qwen3.6-35B-A3B and
Ornith 1.5 on one NVIDIA card and system RAM, with its own gateway for OpenCode.

Made for OpenCode

Setup installs the model together with the FastStrata Gateway,
an app written for OpenCode that sits between it and the model. It turns the model's tool calls into the ones OpenCode
reads, stops a turn that loops, starts the model when OpenCode asks for it and swaps between the installed models.
Setup finds OpenCode (or installs it), adds the provider FastStrata to its config and puts a FastStrata shortcut
on the desktop. LODESTAR, a project memory that keeps a small model to a long task, is in the gateway: off at the
start, one switch turns it on.

Speed

On the test laptop (RTX 3060 Laptop 6 GB, Ryzen 7 5800H, 64 GB RAM), Qwen3.6-35B-A3B UD-Q4_K_M with a 144K context,
against the engine FastStrata started from: writing after a 2K prompt 56.4 → 71.8 tok/s, after 37K 41.9 → 66.9, after
139K 24.7 → 48.8; a coding agent's session 62.4 → 82.8.

Install in three steps

1. Download Source code (zip) below (or git clone) and unzip it anywhere.
2. Windows: double-click START-HERE.bat. Linux: run ./setup.sh. Press Enter to take what it recommends.
3. Start the FastStrata shortcut, open OpenCode and pick a model of the provider FastStrata.

The ready-made engine

strata-poly-windows-x64-3ba1bf3a4bf413eb.zip below holds strata-poly.exe and the image encoder for Windows,
built for RTX 20 to RTX 50 with CUDA 13.0. Setup downloads it by itself and checks its SHA-256
(8be7a559e71ac6da29d0152cec5d911184bfd39b68a6c444b4d95cbcbe33c686), so you do not need to download it by hand and
need no compiler. On Linux, with a driver older than 580 or a CPU without AVX2, setup compiles the engine instead
(about five minutes on the test laptop).

What you need

• An NVIDIA card, RTX 20 or newer: 4 GB of VRAM is the minimum (16K to 48K context), 6 GB is sensible (144K), 8 GB
  is optimal (about 248K, setup's estimate).
• RAM: the engine holds 24 to 29 GB with the 23 GB models and 19 to 22 GB with the 17 GB ones.
• 17 to 24 GB on an SSD for each model; Windows 10 / 11 or Linux.

Every number was measured on one laptop; other cards get setup's estimate less 10%, marked "estimated". Results from
your PC are welcome (how). If setup
stops, open an issue and attach logs/setup-*.log: names and keys are already taken out of it.

All changes: CHANGELOG.md