Nvidia's DGX Station GB300: Desktop AI Agent

The minicomputer shrank into a PC. The PC shrank into a phone. Now the data center is apparently shrinking into something you can set beside your laptop. That last claim is worth examining carefully, because the hardware industry has a long tradition of redefining words like "desktop" until they're doing a lot of heavy lifting.

Developer and YouTube creator Alex Ziskind recently got hands-on time with the ASUS ExpertCenter Pro ET900N G3 — the machine Nvidia markets as the DGX Station — and ran it through a sustained series of concurrency tests that tell a more interesting story than the spec sheet does. The chip inside is the GB300, Nvidia's Blackwell-generation superchip. The GB300 architecture has been shipping in rack-scale configurations for some time; this is the desktop variant, and what makes it unusual is the 748 GB of unified memory it brings to a form factor that can theoretically sit on your desk, assuming your desk can handle the power draw.

That memory architecture is worth understanding before you get to the performance numbers. The DGX Station fuses two pools — high-bandwidth memory running at roughly 7 to 8 terabytes per second, and a larger, slower system memory pool — into a single 748 GB addressable space. Ziskind describes it as "unified memory with a fast lane and a not so fast lane." The practical consequence is that models which fit entirely within high-bandwidth memory run at full speed, while larger models that spill into the slower pool take a throughput penalty. GLM 5.2, a mixture-of-experts model that lands at 465 GB even in its compressed form, illustrated this directly: it couldn't fit entirely in high-bandwidth memory, so tokens that required the offloaded experts had to be fetched from the slower pool. The result was roughly 24 tokens per second for that model, compared to 184 tokens per second for a 120-billion-parameter model that fits cleanly in the faster memory tier.

The compression technique making any of this possible is NVFP4 — Nvidia's own 4-bit floating point quantization format, which the Blackwell chip can execute natively. Quantization is a straightforward trade: you reduce the precision of the model's weights, which shrinks its memory footprint and speeds up inference, at some cost to output quality. Going from 16-bit to 4-bit cuts the model's size roughly by a factor of four. GLM 5.2's 465 GB figure reflects this compression already applied. Without it, models at this parameter count wouldn't fit in any desktop machine's memory. The fact that Nvidia built native hardware support for NVFP4 into Blackwell — rather than emulating it in software — is what actually closes the gap between data center scale and desk scale.

Where Ziskind's testing gets genuinely revealing is the concurrency sweep. Single-user performance is a useful baseline, but it's not the use case this machine is built for. He started with one request at roughly 180 tokens per second, then systematically added simultaneous requests — 2, 4, 8, 16, 32, 64, 128 — watching what happened to total system throughput. The pattern was not what naive intuition would suggest. Total output climbed steadily as concurrency increased, because the GPU's continuous batching packs multiple requests into a single pass. At 128 simultaneous requests, the system was generating over 2,600 tokens per second on the 120-billion-parameter model. Peak throughput across the test run hit just under 5,000 tokens per second.

The catch is per-request latency. As Ziskind notes, "it's not perfect — each individual request takes a little bit longer." That trade-off is real and worth keeping in mind. A single developer querying the model interactively will notice the difference between a snappy single-user response and a response queued behind 127 others. But the point of the test wasn't to optimize for one impatient human — it was to see what happens when you run a swarm of AI agents.

"Running a lot of agents hides two different ideas," Ziskind explains. "One is architecture — how do you wire agents together? Any laptop can do that. The other is throughput — how many actually run at the same time? That is hardware."

That distinction is useful. Agent orchestration frameworks have proliferated over the past two years and most of them will run on modest hardware. What they can't do on modest hardware is sustain dozens of simultaneous agents — each making multiple round-trips to the model, each carrying substantial context in its prompts — without grinding to a halt. The DGX Station's agent demonstration showed 64 concurrent agents generating roughly 3,500 tokens per second, with the machine drawing around 900 watts at that load. Scaling to 128 agents pushed power draw toward 1,000 watts while continuing to produce output — slowly enough per agent that you'd notice it in production, but without the system collapsing.

This desktop AI supercomputing category is expanding rapidly, with multiple vendors now shipping GB-series hardware in workstation form factors. The DGX Station is currently among the most capable single-node options in this class, though "on your desk" remains a somewhat generous description for a machine that Ziskind himself plugged into a 240-volt, 20-amp outlet to avoid reliability problems.

The economics are the most interesting variable. Ziskind frames the pitch plainly: "24/7, 100 agents, nothing leaves your desk. Zero per token cost. Of course, you have to buy the box. And these boxes are not cheap." That's an honest summary of the trade-off. Cloud API costs for sustained, high-volume inference are real and add up quickly at scale. A machine like this amortizes those costs over time while keeping inference on-premise — which matters for teams with data privacy requirements or latency constraints that cloud routing can't satisfy. The electricity bill is not zero, and the capital expenditure is substantial. Whether the math works in your favor depends almost entirely on your actual inference volume and how long you intend to run the hardware.

What the GB300 DGX Station does not do is change the underlying economics of AI development for most organizations. A team running occasional queries against a model doesn't need this machine, and the cost of acquiring one would represent a poor allocation of resources compared to cloud pricing at low utilization rates. The case for on-premise hardware at this tier becomes compelling only when you're running inference continuously, at scale, with models large enough to require the memory this machine provides.

That's a real market — research institutions, larger development teams, companies building AI-native products at volume. It's also a narrower market than the enthusiasm around desktop AI supercomputers sometimes implies.

The question the next few years will answer is whether the software ecosystem catches up to what this hardware can actually sustain. The GB300 can run 128 agents simultaneously. Whether any current agentic framework can usefully deploy 128 agents on a single task — with coherent outputs, without redundant work, without the orchestration overhead swamping the throughput gains — is a different problem entirely, and one that no amount of memory bandwidth solves.

Bob Reynolds is Senior Technology Correspondent at Buzzrag.