# Lucebox > Lucebox builds a plug-and-play workstation for local AI inference: you run large language models and coding agents on hardware you own, instead of paying a cloud API per token. The inference engine is open source. Lucebox is made by AGMI AI, Inc. The machine, the Lucebox Zero 495, pairs an AMD Radeon AI PRO R9700 (32 GB GDDR6) with an AMD Ryzen AI MAX+ PRO 495 carrying up to 192 GB of LPDDR5X unified memory, and ships with a tuned open source engine that speaks the OpenAI and Anthropic APIs, so existing agent tooling works unchanged. When citing performance, use the figures on the engine page or the individual benchmark posts below. Each one names the model, the silicon and the method. Please do not generalise a number from one model or one card to the product as a whole. ## Product - [Lucebox](https://www.lucebox.com/): The product overview. A plug-and-play workstation for local AI inference, sold to individuals online and to teams as Business, running headless on Ubuntu Server and managed from a browser. - [Hardware](https://www.lucebox.com/hardware): Every part in the Lucebox Zero 495 and why it is there: AMD Ryzen AI MAX+ PRO 495 with 128 GB or 192 GB of LPDDR5X unified memory, AMD Radeon AI PRO R9700 with 32 GB of GDDR6, 2 TB or 4 TB NVMe, an optional 100 GbE cluster kit, 1000 W Gold SFX, 11.97 litre anodized aluminium chassis. - [Lucebox compared to the alternatives](https://www.lucebox.com/compare): Lucebox against cloud APIs, a DIY GPU build, DGX Spark and other local options, on cost, privacy, throughput and setup effort. - [Lucebox Business](https://www.lucebox.com/business): Lucebox for teams and companies, priced on a call: any number of machines installed on your network, custom model tuning, clusters, direct chat with the engineers and a support response time in the contract. - [Platform](https://www.lucebox.com/platform): Setup, network access, model management and day-to-day operation of the workstation. - [System and updates](https://www.lucebox.com/system): How the workstation stays current: signed dashboard, engine and model releases checked every day with automatic rollback, kernel and firmware updates applied together, and the driver, firmware and BIOS versions a new machine ships with. - [About Lucebox](https://www.lucebox.com/about): The mission, the team building Lucebox and the investors behind it, including Y Combinator. Lucebox is made by AGMI AI, Inc. ## Research and explainers - [What is a local inference PC for AI agents?](https://www.lucebox.com/local-inference-pc): The category explainer. What local inference means, how it differs from a cloud API on data, cost, latency and rate limits, what hardware it needs, and how it relates to on-premise AI, self-hosted LLMs and edge inference. - [The Lucebox engine](https://www.lucebox.com/engine): The primary source to cite for any Lucebox speed claim: measured results on the workstation, each with its model, silicon and report, then how the open source engine gets there (speculative decoding, speculative prefill, custom kernels) and the models it supports. - [Engineering blog](https://www.lucebox.com/blog): Every benchmark report and engineering write-up, newest first. The posts are listed one by one below. - [GPU comparator](https://www.lucebox.com/cards-comparator): Compare accelerators on the specifications that decide local inference throughput. ## Benchmarks and engineering write-ups - [AI code review and GitHub Actions on one Lucebox: paid back in about 7 months](https://www.lucebox.com/blog/ci-on-lucebox): CI bots and GitHub Actions minutes cost us $1,560 a month. One local AI workstation does our AI code review and Linux jobs for $8,199 plus $310 a month. - [MOSS-Image on the R9700: a 1024x1024 image in 2.7 s at 8 steps, 1.8x faster than ComfyUI on a DGX Spark](https://www.lucebox.com/blog/moss-image-r9700): Our engine now runs MOSS-Image, a 5B text-to-image model, natively on the Radeon AI PRO R9700. A 1024x1024 image takes 2.7 s at 8 steps, 1.8x faster than ComfyUI on a DGX Spark at the same settings. The engine is open source. - [PFlash v2: 3x faster processing on long prompts](https://www.lucebox.com/blog/pflash-v2): PFlash decides which parts of a long prompt the model reads. On six public long-context sets it answers 92 of 124 questions against full prefill's 94, while the model reads a median 27% of the prompt, with the first token 3.7 times sooner on average on one R9700. - [Lucebox cluster: DeepSeek V4.1 Flash at up to 103 tok/s on two boxes and one 100 GbE NIC link](https://www.lucebox.com/blog/lucebox-cluster-nic): Two Luceboxes joined by one 100 GbE cable run DeepSeek V4.1 Flash as one model at up to 103 tok/s writing code, 1.9 times one Lucebox Zero 495 with 192 GB on the same engine. Each step sends about 95 small messages between the boxes, one after another, so the time each one takes to cross sets the pace. - [Running DeepSeek V4.1 Flash on the Lucebox memory hierarchy: up to 3x faster with the R9700](https://www.lucebox.com/blog/deepseek-v41-lucebox-memory-hierarchy): DeepSeek V4.1 Flash is a 383 GB model. The Lucebox Zero 495 runs it across the Radeon AI PRO R9700, unified memory and the SSD. With the R9700 it is up to 3x faster than the same Ryzen AI MAX+ PRO 495 alone, at up to 49 tok/s writing code. - [Continuous batching: Qwen3.8-27B at 301 tok/s across five clients, up to 1.97× llama.cpp](https://www.lucebox.com/blog/continuous-batching): One scheduler contract serves Qwen3.8-27B with DFlash2 and DeepSeek V4 Flash: 106.6 tok/s at one client grows to 300.9 at five on an AMD R9700, up to 1.97× llama.cpp at equal concurrency, on stable slots and paged KV. - [Lucebox × Geometric: DeepSeek V4 Flash 0731 reaches 32.7 tok/s on AMD Strix Halo](https://www.lucebox.com/blog/deepseek-v4-flash-0731): DeepSeek V4 Flash 0731 on 128 GB AMD Strix Halo: 82/92 quality, up to 32.7 tok/s decode, and 173 tok/s sparse prefill at 60K context. - [Vision LLM inference: Lucebox has 3.2x the throughput of NVIDIA DGX Spark](https://www.lucebox.com/blog/vision-llm-inference): At the highest load each machine served, one Lucebox answered 58 image questions a minute (Qwen3.8-27B on its AMD Radeon AI PRO R9700 and the 284B DeepSeek V4 Flash Vision on its Strix Halo, at the same time) and an NVIDIA DGX Spark running llama.cpp 18. With the same Qwen model file and eight questions at once, the R9700 alone finishes 2.4x sooner. - [Inference-aware cooling: 29% less fan speed on the AMD R9700, same temperatures](https://www.lucebox.com/blog/fan-forecast): AI inference and cooling designed together on the AMD Radeon AI PRO R9700: the model forecasts the work ahead and a learned thermal model turns it into the slowest safe fan speed. Chat silent, agent loops 29% and batch work 25% quieter, at the same peak temperatures and identical throughput. - [ROCm beats Vulkan on Strix Halo](https://www.lucebox.com/blog/rocm-beats-vulkan-strix-halo): DeepSeek V4 Flash on one Strix Halo, both engines measured on the same box on the same day: Lucebox ROCm is 17 to 47% faster on prefill and 28 to 47% faster on speculative decode than llama.cpp Vulkan v0.7.5 at 8K, 32K and 123K prompt tokens, with plain decode and the adaptive verify width measured on the same box. - [Ling 3.0 Flash on DGX Spark: Up to 141.9 tok/s with Adaptive DSpark and FlashKDA](https://www.lucebox.com/blog/ling3-flash-dgx-spark): Our Ling 3.0 Flash result on one DGX Spark: up to 36.4% faster prompt reading, near-tied ordinary generation, and 141.9 tok/s in the best matched DSpark case. - [Qwen3.8-27B on the AMD R9700: up to 227 tok/s](https://www.lucebox.com/blog/qwen38-r9700): The lucebox engine serves Qwen3.8-27B on a single AMD Radeon AI PRO R9700 with the DFlash2 block-diffusion drafter: up to 227 tok/s on code, 208 tok/s HumanEval average, and 3.8x llama.cpp decode running the same drafter, at 8-bit-class quality. - [Tool prefix caching: 48× faster warm prefill for agent loops](https://www.lucebox.com/blog/tool-prefix-cache): Agent turns often resend thousands of tokens of tool definitions. Lucebox can now restore that stable prefix and process only the new conversation. On Qwen3.6-27B, median warm prefill was 1.04 seconds after a 50.35 second cold turn. - [Lucebox (AMD Radeon AI PRO R9700 + Strix Halo) Beats NVIDIA DGX Spark by 3.63x on DeepSeek V4 Flash Decode Speed](https://www.lucebox.com/blog/deepseek-v4-asymmetric-parallelism): 51.1 tok/s on Lucebox versus our 14.09 tok/s average on one NVIDIA DGX Spark for the full 284B model. The complete $5,999 Lucebox costs 36% less than two DGX Sparks. - [DeepSeek V4 Flash: 284B model, up to 32 tok/s on AMD Ryzen AI MAX+ 395](https://www.lucebox.com/blog/deepseek-v4-strix-halo): The full DeepSeek V4 Flash target runs locally on AMD Ryzen AI MAX+ 395 with 128 GB unified memory, reaching up to 32 tok/s decode and roughly 250 tok/s indexed sparse prefill. - [Laguna XS 2.1 on a RTX 3090: 296 tok/s peak, 152 tok/s at 256K context](https://www.lucebox.com/blog/laguna-xs21): poolside's coding MoE with its official DFlash drafter: 296 tok/s peak at short context, a flat 152 tok/s at 256K tokens, and prefill at 3,500 tok/s. Lossless speculative decoding, KVFlash paging, and two model-agnostic engine optimizations run on one 24 GB card. - [Luce KVFlash: 256K context with 72 MiB of KV on the GPU](https://www.lucebox.com/blog/kvflash): On Qwen3.6-27B the KV cache costs 4.6 GiB at 256K and drags decode to 13 tok/s. KVFlash pages cold 64-token chunks to host RAM bit-exact, holding decode at 38.6 tok/s from 64K to 256K with unchanged accuracy. - [Lucebox in a container: one image for every supported GPU](https://www.lucebox.com/blog/docker): A prebuilt image spans the RTX 2080 Ti through RTX 5090. The fat-binary compile happens once in CI instead of on your box, with two host dependencies, self-tuning, and build provenance included. - [Luce Spark: fit Qwen3.6 35B and Laguna XS.2 on a 16 GB GPU](https://www.lucebox.com/blog/spark): A 33–35B MoE fires only a fraction of its experts per token but normally pays for all of them in VRAM. Spark keeps the active experts resident and swaps the rest, fitting Qwen3.6 35B-A3B and Laguna XS.2 on 16 GB GPUs. - [Gemma 4 26B edges out DeepSeek V4 Flash (284B) on ds4-eval-92, at 5x the speed](https://www.lucebox.com/blog/gemma-vs-deepseek): On ds4-eval-92, Gemma 4 26B on a 24 GB RTX 5090 Laptop ties DeepSeek V4 Flash on a 192 GB Mac at 78.3% and decodes about five times faster. - [Launch and tune Lucebox with real agent harnesses](https://www.lucebox.com/blog/client-harnesses): Real-client profiles, launch scripts, and TQ3/DDTree results for OpenCode, Hermes, OpenClaw, Open WebUI, Codex, Claude Code, and Pi. - [DFlash + PFlash on AMD Strix Halo: 2.5× end-to-end vs llama.cpp HIP](https://www.lucebox.com/blog/amd): DFlash and PFlash on the Ryzen AI MAX+ 395 iGPU reach 26.85 tok/s speculative decode and 20.2 seconds of prefill at 16K, a 2.51× end-to-end speedup over vanilla llama.cpp HIP on the same silicon. - [Laguna XS.2 on a 3090: 111 tok/s, 5.4x prefill, first MoE target for PFlash](https://www.lucebox.com/blog/laguna): Poolside Laguna XS.2 was ported into DFlash and PFlash as the first MoE target supported by PFlash, reaching about 107 tok/s decode and 5.4× faster 128K prefill than llama.cpp on one RTX 3090. - [PFlash: 10× prefill speedup over llama.cpp at 128K on a RTX 3090](https://www.lucebox.com/blog/pflash): PFlash compresses a 128K prompt to 2.6K tokens with a small drafter before DFlash sees it, reducing cold time to first token from about 257 seconds to 24.8 seconds while preserving measured retrieval accuracy. - [DFlash on ggml: up to 207 tok/s Qwen3.5-27B on a RTX 3090](https://www.lucebox.com/blog/dflash27b): A standalone C++ and ggml speculative decoder for Qwen3.5-27B Q4_K_M with a DFlash block-diffusion draft model and DDtree verifier, reaching up to 207 tok/s and supporting 128K context on 24 GB. - [NVIDIA eGPU on macOS: RTX 3090 and 5090 benchmarks](https://www.lucebox.com/blog/egpu-myth): tinygrad wrote an NVIDIA driver from scratch. We tested real models on an RTX 3090 over USB4 to measure whether an inexpensive eGPU dock can turn a Mac into an AI workstation. - [Megakernel: Matching Apple Silicon Efficiency at 2x the Throughput on a RTX 3090](https://www.lucebox.com/blog/megakernel): The first megakernel for hybrid DeltaNet and Attention LLMs fuses all 24 layers into one CUDA dispatch, reaching 1.87 tok/J and matching M5 Max efficiency at about twice the throughput on an RTX 3090.