LLM Benchmarks · Hardware Deep Dive · Measured on Our Fleet

Gorgon Halo: the 192 GB Ryzen AI Max+ PRO 495Measured on Real Models, Traps Included

Short answerThe 192 GB tier buys exactly one thing over 128 GB: room for the models that do not fit a smaller box. On our Ryzen AI Max+ PRO 495, GLM 5.3 Flash ran as a 98 GB, roughly 2-bit quantization at 28.7 tokens per second on code and 22.9 on prose, and scored 0.957 on our CMMC retrieval battery, within three points of the same model at FP8 in a data center. Smaller models fly on the same box: Qwen3.8 Flash Next reached 89.5 tokens per single stream with prompt reading at about 2,230 tokens per second. The cost of 192 GB is reading speed on the largest models (about 173 tokens per second of prefill on GLM) and a serving-engine field that needs a map. This page is that map.

The community calls this new AMD tier Gorgon Halo, and we have one on the bench: Petronella Technology Group, Inc. runs a Minisforum MS-S1 MAX with 192 GB of unified memory and up to 160 GB addressable as GPU memory (AMD's platform announcement is in Sources). Over November 2026 we tried every AMD-native serving engine we could build or pull, found one crash-grade configuration trap, and ran the models that matter at the context lengths people actually use. Everything below comes from our own box or a cited source; where we did not run it, the text says so.

Five engines tried|128k context windows|OOM trap documented|CMMC quality score
Ryzen AI Max+ PRO 495 mini PC with 192 GB unified memory running large local LLMs, Petronella Technology Group, Inc.
The verdict

What Runs Well on 192 GB, Measured

One row per model and engine, as actually configured on our box. Decode figures are whole-request tokens per second at 300 output tokens unless noted. Prefill is cold prompt reading. The GLM row is the headline capability: a model this large does not fit any 128 GB unified-memory machine we own.

ModelEngine (native AMD)One userStreamsPrompt readingQuality
Qwen3.8 Flash Nexthalogen-flash-server 0.20.389.5 tok/s code, 66.1 prose104 tok/s total at 4 streams (26 each)2,228 tok/s at 13.2k; 2,236 at 37.4kfastest usable path on the box
Qwen3.6-35B-A3B (MLX 4-bit, MTP drafts)TensorFold HIP (built from source, gfx1151)112 tok/s code, 101 prose279 tok/s total at 16 streams1,865 tok/s at 12.8kstrong all-rounder
Qwen3.8 Flash NextTensorFold HIP51 code, 40 prose61 total at 4726 tok/s at 12.8khalogen is 1.75x faster; use it
GLM 5.3 Flash (Maya-S IQ2_XXS, about 2 bits per weight, 98 GB file)Project Maya llama.cpp build, HIP28.7 code, 22.9 prose24.5 total at 4 streams (6.1 each)about 173 to 182 tok/s (50.8 s for a 9,252-token prompt)CMMC RAG 0.957 agentic, 0.925 code-first (1 seed)
GLM 5.3 Flash at IQ4_XSllama.cpp15 tok/s-173 tok/ssuperseded by the Maya build
gpt-oss-120b (MXFP4)llama.cpp41 tok/s--fits in 128 GB too; the 192 GB is not needed for it
DeepSeek V4.1 Flash-no single-box AMD path exists today; two-box USB4 pairs reach 52.8 to 70.6 tok/s on other engines. On NVIDIA we serve it on a four-unit GB10 cluster instead.

Every figure above is read from our stored measurement notes from 2026-11-11 and 2026-11-12 (engine, checkpoint and flags recorded at capture time). The GLM Maya-S quality score is one seed of our CMMC RAG battery; we label it as such rather than averaging an incomplete set.

Deciding between 128 GB and 192 GB? See how we size private AI deployments
Capacity

What 192 GB Buys Over 128 GB (and What It Does Not)

The honest framing: the extra 64 GB buys model capacity, not speed. Memory bandwidth on this class of chip is set by the LPDDR5x memory subsystem, and 192 GB does not make it faster. AMD's announcement for the platform quotes up to 192 GB of LPDDR5x unified memory with up to 160 GB allocatable to the GPU; AMD does not publish a bandwidth figure for the 192 GB part, so we do not quote one. What the extra memory bought in practice:

  • GLM 5.3 Flash at usable quality. The Maya-S quantization we measured is a 98,188,848,711-byte file (about 2 bits per weight). It does not fit a 128 GB box with working context; it fits here with room. The surprise was quality: 0.957 agentic accuracy on our CMMC retrieval battery, against 0.986 for the same model at FP8 on data-center GPUs. Three points of accuracy for running it on a desk.
  • Several mid-size models resident at once. A coder, a reasoner and an embedder can stay loaded together, so switching tasks costs nothing. On a 128 GB box this juggling forces reloads.
  • Long context beside large models. The 495 exposes up to 160 GB to the GPU, and a 98 GB model still leaves five-plus GB per 128k-token stream on the bigger allocations.

What it does not buy: speed. The 98 GB GLM quantization reads prompts at about 173 to 182 tokens per second, so a 27,000-token prompt waits 156.8 seconds for the first answer token. A four-unit DGX Spark class cluster on the same class of model prefills several times faster and our DGX Spark page has those numbers. If your agents re-read big contexts every turn, capacity without prefill speed is a slow capacity. Smaller models sidestep the problem entirely: Qwen3.8 Flash Next on this same box reads prompts at about 2,230 tokens per second, which is competitive.

Software

The Engine Map: What We Tried on the 495 and What Actually Works

The 495 started the month at 15 tokens per second on GLM 5.3 Flash under llama.cpp, which is the number most people will find first. Two native AMD engines changed the picture. Here is the map as of mid-November 2026:

halogen-flash-server: the fast path for Flash Next

halogen-flash-server 0.20.3 runs Qwen3.8 Flash Next at 89.5 tokens per second on code and 66.1 on prose for one stream, 104 tokens per second across four streams, and reads a cold 13,200-token prompt at 2,228 tokens per second (5.9 seconds) or a 37,400-token prompt at 2,236 (16.7 seconds). It is a single container run with the GPU devices passed through; the published recipe and its container image are linked in Sources. It loaded uses roughly 140 GB of the 182 GB the OS exposes while resident, which is exactly the kind of footprint only the 192 GB tier tolerates comfortably.

TensorFold HIP: built from source, best for 35B MoE

TensorFold's AMD backend builds from source for the gfx1151 target (zig plus an AMD ROCm 10 development container). On it, Qwen3.6-35B-A3B in MLX 4-bit with MTP drafts reached 112 tokens per second on code, 101 on prose, 279 across 16 streams, with 1,865 tokens per second of prompt reading at 12.8k. On Flash Next the same engine manages only 51 and 40, so the halogen path wins that model by 1.75x. Both engines are worth having; they are fast on different models.

What does not work yet

  • No single-box GLM or DeepSeek path outside the Maya build. GLM 5.3 Flash runs through Project Maya's llama.cpp fork at 2-bit; DeepSeek V4.1 has no single-box AMD serving path we could find. Community engines run both only as two-node USB4 pairs (GLM 44.5, DeepSeek 70.6 tokens per second published), which is a different purchase.
  • A second community engine failed to compile against GCC 16 and against amdclang on our OS at the time; its published numbers (62 tok/s decode, about 1,700 prefill for Flash Next) remain unverified by us. We note it rather than estimate from it.
  • llama.cpp mainstream remains the floor, 10 to 20 tokens per second on the big MoE models. Treat any llama.cpp figure on this chip as a starting point, not a verdict.

The prompt-cache OOM trap (read this before your first serve)

TensorFold HIP, started with no --prompt-cache-gib value, reserves a 132 GiB prompt cache by default. On a box where the OS and other services need a slice of the same unified memory, the kernel's OOM killer took out the user session, and podman stayed broken until the user service manager restarted. The fix is one flag: always pass --prompt-cache-gib 2 to 8 on this class of box. Every unified-memory server has some version of this trap; the general lesson is that on shared-memory machines the engine's default caches compete with everything else for the same pool, and a default tuned for a discrete-GPU server is a landmine here.

Want the serving recipe we landed on? Talk to Petronella Technology Group, Inc.
Platform

Windows, Linux, and the Memory Allocation Question

The 495 appears in mini PCs, laptops and small workstations, some dual-boot. On our box we measured Flash Next under both Windows 11 Pro and Linux with the same model file and Vulkan: decode was somewhat faster on Linux, and prompt reading faster by a similar margin, consistent with what we saw on the 128 GB sibling chip. The bigger platform variable is the memory split: how much of the 192 GB the firmware exposes as dedicated GPU memory. AMD's platform documentation says up to 160 GB can be allocated to the GPU. The OS also needs its own headroom, and the engines' caches (the OOM trap above) draw from the same pool. Plan the split around your largest model plus two streams of context, and leave the rest to the OS.

Bandwidth context for buyers comparing with our other pages: the 128 GB Ryzen AI Max+ PRO 395 has a rated 256 GB/s subsystem, and the 495's 192 GB configuration runs memory at a higher clock per press coverage (LPDDR5X-8533, about 273 GB/s), though AMD itself publishes no figure for this part and we mark the press figure as a vendor claim, not our measurement. Our own probe on the 192 GB box was not run under the same protocol as the 128 GB machine, so we do not print a number here; the decode figures above are the practical evidence.

A note on what the 182 GB operating figure means for planning. The OS, the container runtime and any agents running beside the server all draw from the same unified pool, so a "192 GB" machine offers roughly 180 GB in practice, and an engine that loads 140 GB of weights (as halogen does with Flash Next) leaves about 40 GB for caches, contexts and everything else. That is generous for one user and tight for several. When we say the box holds a 98 GB model with long context beside it, the arithmetic behind that statement is exactly this: 180 usable, minus 98 weights, minus the prompt cache you deliberately sized, leaves what the KV cache can grow into. Buyers coming from discrete-VRAM thinking should apply the same reserve logic they already know; unified memory just makes the reserve shared with the operating system instead of fixed at the factory.

Honest verdicts

When to Choose a 192 GB Gorgon Halo (and When Not)

If your priority is...ChooseWhy, from our measurements
Running GLM-class models on one quiet desk boxRyzen AI Max+ PRO 495 (Gorgon Halo) 192 GBThe only unified-memory tier that fits a 98 GB GLM quantization with context. Quality measured within three points of the FP8 data-center result.
Fast single-user coding on Flash Next class modelsGorgon Halo (or Mac Studio)89.5 tok/s on code with 2,228 tok/s prompt reading is genuinely fast, and the box holds it plus headroom. The Mac Studio M5 Max 64 GB is faster still on smaller models but caps at 128 GB.
Long-prompt agent fleetsNot this boxIts 98 GB model reads prompts at about 173 tok/s; a GB10 cluster prefills several times faster on the same model class. Buy capacity here for one user who can wait, not for many agents.
CUDA, NVFP4 or vLLM softwareNot this boxAMD native engines only. If your stack is CUDA, our DGX Spark page or the RTX card comparison is the right aisle.
Many users on one modelNot this box, or not one box of itAt 4 streams the 98 GB GLM delivered 6.1 tok/s per stream. Unified memory holds one big context pool but does not carry concurrent load like the data-center tiers.
Cheapest path to a given modelCheck the model firstEverything that fits 128 GB is cheaper on the 395 (our Strix Halo page). Pay the 192 GB premium only for the models that need it.

One-sentence version: buy the 192 GB tier for the models, not for the speed; pair it with realistic expectations about prefill on the largest models, and it is a genuinely capable single-desk AI workstation. Our earlier three-way write-up compares it directly with the Spark and the 128 GB tier on more models: DGX Spark vs Strix Halo vs Gorgon Halo.

Questions we get

Gorgon Halo (192 GB): Frequently Asked Questions

Is a 192 GB machine worth it over 128 GB?

Only if the models you need crowd a 128 GB box. Our 192 GB Ryzen AI Max+ PRO 495 ran GLM 5.3 Flash as a 98 GB, roughly 2-bit quantization at 0.957 CMMC RAG accuracy, but read prompts at only about 173 tokens per second on that model, so long prompts take minutes. Everything that fits in 128 GB is better value on the smaller tier.

What is the fastest model on the Ryzen AI Max+ PRO 495?

That we measured: Qwen3.8 Flash Next on halogen-flash-server, at 89.5 tokens per second on code and 66.1 on prose for one user, with prompt reading around 2,230 tokens per second. Qwen3.6-35B-A3B on TensorFold HIP was close behind at 112 on code with more streams.

Can it run GLM 5.3 Flash?

Yes, as a heavily quantized Maya-S build (about 2 bits per weight, a 98 GB file): 28.7 tokens per second on code, 22.9 on prose, one user. It scored 0.957 on our CMMC retrieval battery, within three points of the same model at FP8 in a data center. A 27,000-token prompt waited about 157 seconds for the first token, so it suits a user who can wait, not a latency-sensitive agent.

Can it run DeepSeek V4.1 Flash?

Not single-box on AMD software today. Community engines run it only as a two-node USB4 pair (about 70 tokens per second published). We serve DeepSeek on a four-unit GB10 cluster instead, where prefill is several times faster.

Why did my server OOM-kill the whole machine?

On unified-memory boxes, engine prompt caches share the pool with the OS. TensorFold HIP without an explicit prompt-cache limit reserved about 132 GiB by default, and the kernel OOM killer took out the user session. Always set an explicit prompt-cache size (we use 2 to 8 GiB) on this class of hardware.

How much memory bandwidth does the 495 have?

AMD does not publish a figure for the 192 GB part. Press coverage of the platform quotes LPDDR5X-8533 at about 273 GB/s; we mark that as a vendor-platform claim rather than our measurement. Practical decode speeds on the models above are the evidence that matters.

Gorgon Halo or DGX Spark for a small team?

For a small team, the Spark: its CUDA software carries concurrent users far better, and four units cluster into models the Halo cannot load at all. The Halo is the pick for one person who needs one very large model with long context and can tolerate slow prefill on it.

Does it run Windows or Linux for local LLMs?

Both. Our Flash Next measurements were somewhat faster on Linux than Windows with the same model and engine, and the community engine ecosystem is Linux-first. Windows dual-boot is fine for evaluation; Linux is where we serve.

Can it do compliance or CMMC work?

The quality score says the model can: GLM 5.3 Flash at 2-bit scored 0.957 on our CMMC retrieval battery (one seed). The box suits a private single-user assistant. Enclave design, not hardware choice, is what makes it compliant; see our CMMC compliance services.

Strix Halo vs Gorgon Halo in one line?

Same family, one question: does your model fit in 128 GB? If yes, buy the 395 tier (our Strix Halo page). If no, the 495's 64 extra GB are the difference between running it and not. Speed per model is close; capacity is the whole decision.

About the author

Craig Petronella

Craig Petronella founded Petronella Technology Group, Inc. in 2002 and leads its private AI and compliance work. He is a CMMC Registered Practitioner (CMMC-RP), Cisco CCNA, Certified Wireless Network Expert (CWNE) and North Carolina Digital Forensic Examiner (License 604180-DFE), and the author of 16 books. His team runs the GPU fleet behind these benchmarks, including the 192 GB box this page documents.

Keep comparing

More Hardware Deep Dives From Our Benchmark Lab

Every page below uses the same prompts, the same quality gate and the same methodology, so the numbers line up across machines.

Sources

Sources and References

Size the Box to the Model, Not the Other Way Around

Send us the model list and the context lengths you actually work with. We will tell you which tier it needs, and benchmark it before you spend. Our team builds private AI systems that keep sensitive data on equipment you control.

Prefer to read first? Explore our AI services or our workstation practice.

Measured on the Petronella Technology Group, Inc. fleet, November 2026. Every number on this page traces to a stored result file with the engine, checkpoint and flags recorded at capture time.