Project Zenith

Project Zenith represents Microsoft's standardized push to deliver an out-of-the-box, ready-to-code local AI development workstation on Windows 11. Built around the AMD Ryzen AI Halo platform, the initial hardware iteration pairs an AMD Ryzen AI Max+ PRO 495 processor with 192 GB of unified LPDDR5X memory. By establishing a rigid hardware baseline of at least 64 GB unified memory and 250 GB/s bandwidth, Project Zenith eliminates the traditional configuration friction of running large neural networks locally while avoiding recurring cloud token costs.

Occupying the high-end prosumer and developer workstation tier, this machine directly challenges large-memory Apple silicon configurations and multi-GPU desktop builds. With up to 160 GB of unified system memory dynamically allocatable as VRAM to the integrated Radeon 8065S GPU, Project Zenith gives developers an accessible platform to load and run high-parameter models on a single compact system. It bridges the gap between consumer GPUs limited by tight VRAM caps and enterprise rackmount accelerators.

For teams deploying autonomous systems, Project Zenith for AI acts as a dedicated environment for complex agentic workflows. Shipping preconfigured with Visual Studio Code, WSL, Python, Git, and developer CLI tools, it is designed to run local foundation models, embedding engines, and code evaluation pipelines immediately after setup without the usual driver or environment troubleshooting.

Evaluating Project Zenith AI inference performance requires looking closely at memory architecture and compute pipelines. Large language models depend primarily on memory bandwidth for token generation latency and memory capacity for overall model footprint.

The platform relies on the AMD Ryzen AI Max+ PRO 495, bringing 16 Zen 5 CPU cores (32 threads boosting up to 5.2 GHz), an integrated Radeon 8065S graphics processor with 40 RDNA 3.5 compute units, and an XDNA 2 Neural Processing Unit (NPU).

• Unified Memory Pool: 192 GB LPDDR5X system memory, with up to 160 GB directly addressable by the GPU.
• Memory Bandwidth: 273 GB/s across a wide memory bus interface.
• GPU Compute: Up to 61 FP16 TFLOPS via 40 RDNA 3.5 compute units.
• NPU Throughput: 55 INT8 TOPS provided by the AMD XDNA 2 engine.
• Host CPU: AMD Ryzen AI Max+ PRO 495 (16 cores, 32 threads, up to 5.2 GHz).
• Software Environment: Windows 11 ready-to-code setup with native WSL, Git, Python, Node.js.NET, Azure CLI, and GitHub Copilot CLI.

The core asset of this machine is its unified memory footprint. Traditional consumer desktop GPUs top out at 24 GB or 32 GB of VRAM, requiring multi-card PCIe topologies to load models larger than 30 billion parameters. Project Zenith functions effectively like a 192GB GPU for AI workloads because the CPU, GPU, and NPU share the same physical memory space.

However, memory bandwidth dictates generation speed. At 273 GB/s, bandwidth sits well above standard dual-channel DDR5 platforms (typically under 90 GB/s), but falls below dedicated GDDR6X or HBM setups found on discrete cards like the RTX 4090 (1,008 GB/s). This design choice prioritizes massive parameter capacity and low power consumption over raw, ultra-fast generation speeds on massive dense models.

Having up to 160 GB of allocatable VRAM fundamentally alters local LLM capabilities. Project Zenith local LLM support spans from fast 8B edge models up to highly quantized 300B parameter models.

• Llama 3.1 8B / Qwen 2.5 7B: Runs entirely unquantized at FP16 or at high-precision INT8. At these smaller footprints, the compute units can saturate the bandwidth, delivering between 30 and 45 tokens per second.
• Llama 3.1 70B / Qwen 2.5 72B: Fits comfortably in VRAM using 4-bit (Q4_K_M) or 8-bit (Q8_0) quantization. An INT4 quantization of a 70B model requires roughly 40 GB of VRAM, leaving over 100 GB for massive context windows (up to 128k tokens) and local KV caches.
• Dense 70B Token Generation: Because reading 40 GB of weights at 273 GB/s presents an arithmetic memory bottleneck, expected generation speed on dense 70B models sits around 5 to 7 tokens per second. While slow for high-volume customer-facing serving, it remains fully functional for asynchronous reasoning tasks and code generation.

Mixture-of-Experts architectures represent the performance sweet spot for this hardware. MoE models route tokens through only a subset of active parameters per forward pass, meaning the system does not need to stream the entire parameter weight set for every token generated.

• Mixtral 8x7B / 8x22B: Mixtral 8x22B (39B active parameters) runs smoothly within the memory pool.
• DeepSeek-V3 / DeepSeek-R1 (Quantized): Project Zenith can load massive MoE models at extreme quantization (IQ2_XXS to Q3_K_M) that would otherwise require multiple server GPUs.
• MoE Generation Speeds: On sparse architectures where active parameter counts hover between 10B and 20B, Project Zenith tokens per second can exceed 50 to 100 tokens per second, making it an exceptional testbed for cutting-edge MoE architectures.

For dense models, 4-bit quantization (such as GGUF Q4_K_M or AWQ) delivers the most practical balance between inference speed and perplexity. More importantly, the massive 160 GB allocatable pool eliminates context exhaustion. Developers can run long-context code analysis tools or load multimodal architectures (like Qwen2-VL or Llama 3.2 Vision) alongside extensive system prompts without triggering out-of-memory errors. It is one of the few compact developer workstations capable of serving as hardware for running 300B parameter models when aggressively quantized.

Project Zenith addresses specific development bottlenecks where standard consumer desktop hardware fails due to memory limits.

• Autonomous Agent Developers: Practitioners running local orchestrators (such as AutoGen, CrewAI, or LangGraph) frequently need multiple models in memory at once: a reasoning model, an embedding model, and a small verification model. Project Zenith provides the unified capacity to keep these services resident simultaneously.
• Local Code Assistance and Tool Execution: With its preconfigured Windows 11 toolchain, developers can run local coding models without sending sensitive internal codebases over cloud APIs.
• Researchers Evaluating Large Quantized Architectures: Building proof-of-concept pipelines on 70B+ architectures usually requires spinning up expensive cloud instances. Project Zenith allows unmetered, zero-latency local iteration.
• Inference vs. Fine-Tuning: This hardware is heavily optimized for inference, context evaluation, and agent execution. While parameter-efficient fine-tuning (PEFT/LoRA) is viable due to the massive VRAM footprint, full-parameter pre-training remains impractical given the 61 FP16 TFLOPS compute ceiling and 273 GB/s memory bandwidth.

When evaluating the best hardware for running AI models locally, Project Zenith occupies a unique position between Apple silicon and multi-GPU desktop workstations.

The Mac Studio has long dominated high-memory local inference. A 192 GB Apple unified memory configuration offers higher memory bandwidth (typically 800 GB/s on Ultra chips), yielding faster token generation on dense 70B models. However, Project Zenith provides a native Windows 11 and Linux (WSL) development stack designed specifically for developers entrenched in the Microsoft and AMD toolchains. For engineers whose tooling depends on native Windows features, DirectX, or ROCm-on-Windows ecosystems, Project Zenith provides comparable unified capacity without forcing a migration to macOS.

A workstation with dual RTX 4090 cards offers drastically higher compute (over 160 TFLOPS FP16 each) and memory bandwidth (1,008 GB/s per card), resulting in dense 70B generation speeds well above 35 tokens per second. However, dual 4090 setups cap out at 48 GB total VRAM (24 GB per card, non-pooled without tensor parallelism overhead), consume upwards of 800 to 1,000 watts under load, and generate substantial heat and noise.

Project Zenith trades away that raw token generation speed in exchange for a continuous 160 GB allocatable VRAM pool in an energy-efficient, small-form-factor design. It easily loads models that would trigger immediate memory crashes on dual consumer GPUs.

For engineers seeking the best hardware for local AI agents 2026, Project Zenith presents a compelling tradeoff: it trades peak dense generation throughput for massive unified capacity, low operational friction, and silent desktop deployment.