Strata Local LLM: Hardware, Install, Coding Agents and Strata vs vLLM

Strata is a free, MIT-licensed local LLM engine that runs large mixture-of-experts models, chiefly Qwen3.8-Flash-Next, on consumer hardware. It keeps the most-used experts on a 12 GB or larger graphics card, the rest in 48 to 64 GB of system RAM and a lookup table on the SSD. It installs as a desktop app or through strata launch, and serves OpenAI- and Anthropic-compatible APIs on localhost for coding agents.

Strata appeared on GitHub on 24 September 2026, with version 0.1.0 published the same afternoon, and had shipped 67 releases by 13 November. The current release is 0.2.13 from 9 November: the app and terminal carry that number, while the engine packages are 0.1.59. Searches for “strata llm” and “strata local llm” rose sharply in Google Trends during November, and many searchers want the same few answers: what fits on their machine, how to install it, how to point a coding agent at it and how it compares with the engines they already use.

This guide answers those questions from the project’s repository, documentation and release notes as they stood on 13 November 2026. Speeds below are the project’s own measurements, labelled with their hardware. For the model itself, our Qwen 3.8 hardware and file-size guide covers Flash-Next in every runtime, not only Strata.

What Strata is, and what it runs

Strata has three parts that share one engine:

• The desktop app, built on Tauri, for people who prefer not to use a terminal. It includes a chat window with file handling and a live code preview, and a built-in coding agent.
• The terminal tool, the strata command, which downloads an engine and a model, serves it, watches it and connects other apps to it.
• The engine and server: C++ with CUDA, HIP, SYCL and Metal back ends, plus a Python server that speaks the OpenAI and Anthropic APIs.

The project currently supports three model families:

For Flash-Next, Strata recommends ISTA-DASLab’s compressed packs first, then Unsloth’s 4- to 8-bit files, then agentionai’s Gyro packs, which use the least memory and run slower. The project says this order reflects the maintainer’s working relationship with ISTA-DASLab, not a measured quality ranking. Variants include ISTA-DASLab’s Coder pack, which keeps half of each layer’s experts chosen on code, UkisAI’s Swift 1.5 fine-tune, which thinks for fewer tokens, and three NVFP4 builds for NVIDIA cards. The Strata code is MIT-licensed, but every model keeps its own licence: Flash-Next ships under the Qwen Community License 1.0.

The 0.2.13 notes also describe “Qwen4 groundwork”: the signed update feed can now carry a model list, and a model of a new shape gets its own engine download. No Qwen4 model was in the feed on 13 November; our Qwen 4 overview tracks that release separately.

How Strata fits a 180B model on a 12 GB GPU

Qwen3.8-Flash-Next is a mixture-of-experts model with 24,576 small expert networks, 512 in each of 48 layers, and each token uses only 10 of them. Runtimes that load every weight into GPU memory need roughly 94 to 120 GB for a 4-bit build. Strata spreads the model across the whole computer instead:

• GPU memory holds the parts every token needs (attention and DeltaNet layers, routers, shared experts, the output head, the draft layer and the KV cache), then fills what is left with the experts used most often. That cache adapts during the conversation, and the project estimates each extra gigabyte holds about 700 more experts.
• System RAM holds every expert. When a token needs one that is not on the card, the CPU computes it in place, in parallel with the GPU.
• The SSD holds a 28.8 GB n-gram lookup table, of which the model reads only a few rows per token.

Two techniques claw back speed. The model’s own multi-token prediction (MTP) layer drafts up to three tokens, and the full model checks them in a single pass; Strata reports 1.6 to 1.8 times faster answers with identical output. Long prompts are read in chunks of up to 8,192 tokens while the next layer’s experts stream over PCIe.

The trade-off is that system RAM, CPU speed and PCIe bandwidth matter as much as the graphics card. If RAM is short, Strata can read experts from the SSD, which works but is much slower.

Strata hardware requirements: GPU, RAM and Mac memory

Sources disagree on the minimum because the answer depends on the pack. The project’s own rule for Flash-Next is that RAM must hold the experts plus about 10 GB for the operating system, and that a graphics card of 12 GB or more is recommended for every vendor.

The three smaller ISTA-DASLab packs download as 66 to 76 GB, and the first start fetches the MTP draft layer, about 6 GB more. A larger card speeds things up but does not reduce the RAM requirement, with one exception: a low-RAM mode maps experts from disk, so a 32 GB PC with a 24 GB card can run Q2_0, IQ2_XS and the Coder, at a cost in speed. Our VRAM calculator gives the same arithmetic for runtimes that keep everything on the GPU.

Strata on 8 GB and 12 GB cards

Twelve gigabytes is the recommended floor, and most of the published numbers come from 12 GB cards such as the RTX 3060 and RTX 5070. The documentation also records community runs on 8 GB cards, an RTX 2060 SUPER and an RTX PRO 2000 Laptop GPU, with an option written specifically for 8 GB cards. Treat 8 GB as possible but slower, with fewer experts cached.

Strata on AMD, Intel and the DGX Spark

The supported AMD list covers Radeon RX 7700, 7800 and 7900, RX 9060 and 9070, and the Radeon AI PRO R9700, with RX 6800 and 6900 cards marked experimental. Ryzen AI Max (Strix Halo) has its own guides for Linux and Windows. Intel Arc A- and B-series cards run on Linux only, after a model-preparation step. The NVIDIA DGX Spark runs through the terminal; there is no ARM64 Linux desktop app. Our R9700 guide covers that card’s ROCm setup in other runtimes.

Strata on a Mac

Strata needs Apple Silicon (M1 or newer) and macOS 15 or newer; Intel Macs are not supported. Metal lets one program keep about three quarters of unified memory resident, which sets the tiers: Q2_0 needs about 46 GB and is recommended from 64 GB, IQ3_S needs about 63 GB and is recommended from 96 GB, and Unsloth’s UD-Q4_K_XL is recommended from 128 GB. Macs with 32 to 48 GB stream experts from the SSD. The 64 GB figure sometimes quoted as a hard Mac minimum applies to DeepSeek V4.1-Flash, not to Flash-Next.

What speeds the project reports

These are the maintainers’ figures on their own machines, several engine versions old in places, and the project itself warns that output speed varies with the text. Independent benchmarks were not available to us; measure on your own hardware before planning around them.

How to install Strata: desktop app or strata launch

Desktop app. The release page offers one installer per system: Strata-0.2.13-windows-x64-setup.exe, Strata-0.2.13-linux-x86_64.AppImage and Strata-0.2.13-macos-arm64.dmg. The Windows and Linux installers contain no engine; on first start the app shows the engine for your graphics card with its size and a Download button, or installs an engine file you already have. The Mac image includes its Metal engine. You then pick a model and a storage folder and wait for the download. The Windows installer needs no administrator rights.

Terminal. On Linux or macOS, download and run the project’s install.sh from the latest release; on Windows, run the PowerShell installer named in the README, then open a new terminal. Both install into your home folder without administrator rights. Then:

strata launch                                         # guided screens
strata launch --plan --family qwen --model q2_0       # show what would download; changes nothing
strata launch --family qwen --model q2_0 --yes --no-tui
strata launch --status
strata launch --stop

Useful flags include --context (32K to 256K), --vision off, --parallel N, --access local|lan|cloudflare|tailscale, --port and --model-path for files you already have. CUDA 13 engines need NVIDIA driver 580 or newer, and older NVIDIA cards fall back to a CUDA 12 engine. Updates are a separate, explicit step: strata update, or the update buttons in the app’s Settings.

A third-party project, Strata Manager, is often found in the same searches. It is an MIT-licensed desktop manager created by a different developer on 10 October 2026, not part of the official project.

Connecting coding agents: OpenCode, Claude Code and Codex

By default the server answers at http://127.0.0.1:8080 with three request APIs:

The strata connect command lists ready-made adapters for Claude Code, Codex CLI, OpenCode, oh-my-pi, pi.dev, Hermes Agent and OpenClaw. Running strata connect opencode prints the configuration with the address, key, model and context already filled in; --write saves it after asking and backs up what it replaces, and --check sends one prompt and one tool call the way that tool would. The project tested each adapter against a 32K-context server, with OpenCode 1.19.3, Codex CLI 0.163.0 and Claude Code 2.1.302. Port 8080 is also llama-server’s default, so pass --port if both run on one machine.

OpenCode. The adapter writes ~/.config/opencode/opencode.json with a provider that uses @ai-sdk/openai-compatible and baseURL set to the /v1 address. The documented gotcha is limit.input: without it OpenCode never compacts its conversation. OpenCode’s prompt and tools take about 7,400 tokens of the window. Our OpenCode local model setup explains the provider block in general.

Claude Code. Claude Code reaches Strata through the Anthropic Messages endpoint. Set ANTHROPIC_BASE_URL=http://127.0.0.1:8080 without /v1, because Claude Code appends /v1/messages itself. Also set CLAUDE_CODE_MAX_CONTEXT_TOKENS to the served context and CLAUDE_CODE_MAX_OUTPUT_TOKENS; otherwise Claude Code assumes a 100K window and compacts at the wrong time. Its full prompt is about 15,600 tokens, so at 32K context the adapter sets CLAUDE_CODE_SIMPLE=1, which cuts the tools to three. No Anthropic account is involved; Anthropic does not support third-party models in Claude Code, so problems are yours to debug. Our Claude Code local setup guide covers the same variables with other servers.

Codex CLI. Codex works because Strata implements the Responses API. The provider in ~/.codex/config.toml uses wire_api = "responses" and reads its key from STRATA_API_KEY, which must be set even when the server has no key. Strata’s Responses endpoint is stateless, so previous_response_id and background requests are refused. Our Codex local model guide explains why Codex needs that API.

Whatever the agent, the window you start with limits it. Coding agents spend thousands of tokens on their own instructions, so 64K or 128K context leaves far more room than the 32K the adapters were tested at, if your RAM allows.

Strata’s thinking budget parameter

Flash-Next reasons before it answers, and its default level is high. Strata exposes control in three places:

The effort levels are instructions the model was trained with, not hard limits. A token budget is enforced: when thinking reaches the cap, the server closes it with a short wrap-up line and the model answers from there, and the wrap-up counts towards output tokens. An Anthropic budget_tokens value also maps to a level (under 2,000 is low, under 8,000 medium, anything higher high). A request’s own reasoning_budget_tokens, or llama.cpp’s thinking_budget_tokens, overrides the server setting. A separate answer_room setting, on by default, wraps up thinking when a quarter of a request’s max_tokens remains, so long reasoning does not crowd out the answer.

Is Strata secure? What it listens on and what it sends

Strata’s SECURITY.md and privacy page answer most of what a cautious reviewer would ask:

• Listening address. The server binds to 127.0.0.1 by default. --access lan opens it to your network and creates an API key; Cloudflare and Tailscale options exist too. --no-api-key serves without a key and prints a warning rather than refusing.
• Authentication. When a key is set, it is required on every /v1/* route, every POST and every endpoint that reveals prompts or state, and it is compared in constant time. Without a key, the server answers only known host names (a DNS-rebinding defence) and rejects browser requests to /v1/* from other websites. CORS is off by default.
• The app. Its own host process listens on 127.0.0.1, port 8791 by default. “Share with other devices” opens a separate listener that requires a key and answers only /v1/models, /v1/chat/completions and /v1/messages.
• Telemetry. The project states Strata sends no usage data, crash reports or analytics, and that the engine itself contains no networking code. Network use is limited to downloads, updates and features you switch on, such as the agent’s web search, outside model providers or a tunnel.
• Updates. Engine updates come from an Ed25519-signed feed, each package is checked against its SHA-256 before it is test-started, and a failed update keeps the old engine.

Two caveats come from the project itself. For a first install by piped script, trust rests on HTTPS and on the GitHub release, so readers who want more should download and read the script first, or build from source. And Strata has not yet had an outside security audit. Our OpenClaw risk review shows why any local agent with shell access needs separate controls, whichever engine sits behind it.

Project maturity

Strata is young and moves quickly. On 13 November 2026 the repository showed more than 43,000 stars, 675 open issues and 724 open pull requests. The maintainer has written the large majority of commits; more than 300 accounts have contributed, most with a handful of changes such as back-end ports and fixes. Releases arrive every few days, and the 0.2.13 notes list known problems openly. That pace suits enthusiasts; anyone depending on it should pin a version and test updates first.

Strata vs vLLM vs llama.cpp vs LM Studio vs Unsloth Studio

Strata vs vLLM. These answer different questions. vLLM, like SGLang, is a production server that batches many simultaneous requests and splits models across GPUs; it assumes the hardware can hold the model. Strata assumes it cannot, and optimises for one person on one machine. Strata does borrow vLLM’s Prometheus metric names, so existing vLLM dashboards can read it. Our vLLM, Ollama and llama.cpp comparison covers the server side in depth, and our NIM, vLLM and Ollama comparison adds NVIDIA’s packaged option.

Strata vs llama.cpp. Strata builds on parts of llama.cpp and ggml and uses its GGUF files, then adds its own engine paths for expert caching and drafting. The project’s measurements favour Strata on its supported models: on an M5 Max, 108.2 tokens per second against 56.6 for llama.cpp with the same Q2_0 file, and on Qwen3.6 with several simultaneous requests, 1.14 to 1.62 times llama-server’s throughput. These are the project’s comparisons, not independent tests. llama.cpp runs far more models, has a longer history and moves at a steadier pace.

Strata vs LM Studio, Bionic and Unsloth Studio. LM Studio and Unsloth Studio are apps over llama.cpp-style engines with broad catalogues; Unsloth Studio’s main job is fine-tuning, as our Unsloth Studio and LM Studio comparison explains. The overlap with Strata is the model files: Strata runs Unsloth’s dynamic quantizations of Flash-Next with --family unsloth. LM Studio’s catalogue listed Flash-Next with a 96 GB minimum when we checked, which is the gap Strata targets. LM Studio Bionic is an agent app whose documented model sources are LM Studio’s own runtime, LM Link and its hosted cloud, and Strata’s adapter list does not include it; our LM Studio Bionic guide has the detail.

When Strata is not the right tool

• Team serving. Strata has one API key per server and no user accounts, roles or per-user logs. Parallel slots let a few requests run together, but it is a personal engine, not a shared service.
• Models outside its list. If your organisation standardises on Llama, Mistral, gpt-oss or a fine-tuned model of its own, Strata will not run it today.
• Production change control. Releases every few days, a single core maintainer and no outside audit argue for pinning versions, or for a more established server where uptime matters.
• Data-centre GPUs. On cards that hold the whole model, Strata’s offloading buys little, and vLLM or SGLang will usually serve more users.

Strata is a strong fit for a developer who wants Flash-Next or DeepSeek V4.1-Flash on their own workstation, privately, with a coding agent attached.

How VDF AI fits

VDF AI does not run, host, bundle or integrate Strata, and our documentation does not list it as a supported model source.

The gap Strata leaves is the one VDF AI is built for. A single developer’s engine does not answer who may use a model, what they sent it or which documents it saw. VDF AI is an on-premises and private-cloud platform for governed AI agents and multi-agent workflows (VDF AI Networks), private RAG over company documents, role-based access control on every plan and audit logs.

VDF AI Router registers Ollama and custom on-premises model deployments beside the cloud models your policy approves, prefers local models when they are available and accepts OpenAI-compatible endpoints as sources. In principle that could include a Strata server, but it is untested and undocumented, so prove it in a pilot before relying on it. Air-gap mode keeps routing on local models. Production self-hosting runs on Linux, with macOS for evaluation, as our infrastructure requirements explain.