The $2,000 Local AI PC: A Reference Architecture

This is a reference architecture, not a tested build. Every component here is specified from published manufacturer documentation — socket, TDP, connector type, memory support, dimensions — and the parts are specified to work together on paper. Nobody at AI Gear Stack has assembled this machine.

That distinction matters enough to lead with, because the failures that ruin a first build are almost never visible on a spec sheet. A cooler that overhangs the first memory slot. A card the case manufacturer lists as supported that turns out to need four millimetres you do not have once the front fans are fitted. A motherboard revision shipping firmware older than the CPU it is rated for.

What is establishable from documentation is the reasoning: which tier of card to buy, why capacity beats speed for this workload, how much power headroom a transient-spiking GPU needs, and what the finished machine will actually run. That is what follows, and it ends with a checklist of what to confirm against your own basket before you order.

A note on price

You will not find dollar figures against products anywhere on this site — our editorial policy commits us to never publishing a price we cannot verify at the moment you read it, and a figure captured at writing is wrong within days.

The number in the title is a capability tier, not a receipt. It describes a machine built around a 16–24 GB graphics card with the rest of the system specified not to bottleneck it, which is what roughly two thousand dollars has bought for the past several product cycles. Check current prices yourself. At this tier the used market moves enough that the ordering genuinely changes.

The one decision that shapes everything else

Every other choice in this build follows from how much VRAM you buy, so make that decision first.

Local language model generation is memory-bandwidth-bound: the machine reads the model’s active weights out of memory to produce each token, so capacity decides which models you can run at all, and bandwidth decides how fast. Compute barely registers. This is why an AI build looks so unlike a gaming build — you spend on the card’s memory and starve everything else, and the result is faster than a balanced machine costing the same.

That gives two credible paths at this tier.

The bandwidth figures are close enough that tokens per second on a model that fits in both cards will be similar. The 3090 is not the faster card in any general sense — it is two generations older and materially less efficient. What it has is eight more gigabytes, and eight gigabytes is the difference between running 14B-class models and 32B-class models, which is a larger jump in output quality than anything else available at this budget.

Take Path A if the capability step matters more to you than the warranty, and you are comfortable buying used hardware. Take Path B if it does not, or if the machine is doing image generation as much as text — diffusion is compute-bound, which inverts the comparison entirely and puts the newer card well ahead.

The rest of this specification is identical for both, except where noted.

The component specification

Read that as a specification rather than a shopping list. The requirements — socket, capacity, connector type, clearance — are the part that holds; a named model is one example that satisfies them.

Why each part is what it is

The graphics card

Covered above, and it is roughly two-thirds of the budget. That ratio is correct for this workload and would be indefensible for almost any other.

The CPU: deliberately unremarkable

Once the model fits in VRAM, the CPU does almost nothing during generation. It feeds the GPU and gets out of the way. A Ryzen 7 9700X is specified here because it is fast in single-thread terms, runs at 65 W so it never fights the graphics card for thermal or power budget, and costs a fraction of what the equivalent enthusiast part does.

Spending more on the CPU is the most common way to build a worse AI machine at the same price. The exception is if you intend to run models larger than your VRAM, where layers spill into system memory and the CPU does have to do real work — but that path is so much slower that the right answer is almost always to run a smaller model rather than build for it.

Memory: two sticks, not four

64 GB in two DIMMs, and this is a genuine compatibility trap rather than a preference.

AM5 runs its memory controller comfortably at DDR5-6000 with two single-rank or dual-rank modules. Populate all four slots and the controller frequently will not hold that speed — DDR5-3600 to 4400 is a common landing point, sometimes needing manual tuning to boot at all. Buying 2 × 32 GB rather than 4 × 16 GB costs slightly more per gigabyte and leaves both the speed and a future upgrade path intact.

64 GB is specified rather than 32 because model files are large, several tools memory-map them, and the machine is more pleasant to use when the page cache is not constantly evicting a 20 GB file you are about to load again.

Storage: capacity first

A single 2 TB NVMe drive. Model weights are the largest files most people will ever store routinely — a handful of quantised 32B models and a couple of image models will pass a terabyte without much effort.

PCIe 4.0 is sufficient. Load time scales with sequential read, and the difference between a good 4.0 drive and a good 5.0 drive is a few seconds on a load that happens once per session. Sustained write performance and drive endurance matter more here than the headline number, which is why the guide to NVMe SSDs for AI workloads spends most of its length on the SLC cache cliff rather than on peak figures.

The board specifies two M.2 slots so the second drive is a later decision rather than a rebuild.

The power supply: sized for spikes, not averages

850 W, which looks generous against a 350 W card and a 65 W CPU, and is not.

The reason is transient behaviour. GDDR6X-era NVIDIA cards, the 3090 emphatically included, draw brief current spikes well above their rated board power — microsecond-scale excursions that never show on a wall meter but are exactly what trips a power supply’s over-current protection. A machine that reboots under load rather than crashing is nearly always this. Modern ATX 3.1 units are specified to tolerate those excursions; older units of the same wattage frequently are not, which is why the standard and not just the number is part of the specification.

Specify native 12V-2×6 on the supply side. The adapters work, but a native cable is one fewer connection to seat imperfectly, and imperfect seating on this connector is a well-documented failure mode with consequences beyond an unstable machine.

Path B’s 300 W card is comfortable on a 750 W unit of the same standard.

Cooling and case: where the specification meets reality

The CPU is 65 W and needs almost nothing. The case has to handle a card dumping 300–350 W into it for hours at a time, which is a different problem from gaming — sustained rather than bursty, and with no pauses for the thermal mass to recover.

Specify front intake fans, and confirm the case has them fitted rather than merely supported. The pattern that causes long-run throttling is a case with excellent reviews and one exhaust fan in the box.

For the cooler, a 240 mm AIO or a large dual-tower air cooler both work. Air is cheaper and has no pump to fail; check the height against the case and the memory clearance against your DIMMs, because tall heat spreaders and wide coolers are the classic collision.

What the finished machine runs

Assuming Path A’s 24 GB, and Q4_K_M quantisation, which is the quality-per-gigabyte sweet spot for most people:

The rough arithmetic, which the VRAM calculator explainer works through properly: a Q4_K_M model occupies roughly 0.6 GB per billion parameters, so 32B lands near 19 GB, leaving a few gigabytes for the KV cache. Long context consumes that remainder quickly, which is why 32B on a 24 GB card is comfortable at ordinary context lengths and tight at very long ones.

Path B’s 16 GB card handles the 13–14B tier the same way and does not reach 32B at Q4.

Before you order: verification checklist

This is the part a specification cannot do for you. Each of these is a number to confirm against the specific parts in your basket, not the category.

1. GPU length against case clearance. Find the length of the exact card model — third-party 3090s range from roughly 310 to 340 mm — and check it against the case’s stated maximum with front fans fitted, which is often 20–30 mm less than the headline figure.
2. GPU slot width. Many 3090s are 2.7 or 3 slots. Confirm nothing below the card is blocked, and that the case has the slots.
3. Cooler height against case width, and cooler width against DIMM height if you are using air.
4. PSU connector count and type. A 3090 typically needs three 8-pin PCIe connectors, or a native 12V-2×6 depending on the model. Confirm which your card has and that your supply provides it without adapters where possible.
5. Motherboard BIOS version against CPU support. Boards that have sat in a warehouse ship old firmware. Confirm the board supports your CPU out of the box, or that it has USB BIOS flashback so you can update without a working CPU.
6. Memory on the board’s QVL at the speed you intend to run, in a two-DIMM configuration.
7. Front-panel and case fan headers. Trivial and routinely forgotten.
8. If buying a used card: ask for photographs of the PCB and the power connectors, confirm the fans spin freely, and budget for replacing the thermal pads. The 3090’s GDDR6X modules sit on the back of the board and ran hot from new; degraded pads are the normal condition of a five-year-old card, not a defect unique to a bad one.

If any of those checks fails, the failure is in this specification’s applicability to your parts, not in your reading of it. Substitute and continue.

Where to spend more, and in what order

If the budget stretches, the order is not the one most build guides give.

1. More VRAM. Always first. A 24 GB card over a 16 GB card changes what the machine can do; nothing else on this list does.
2. A second NVMe drive. The cheapest quality-of-life improvement, and the one you will want soonest.
3. More system memory, if you work with several large models in a session.
4. A better case, with better fans. Sustained loads reward this more than the spec sheet suggests.
5. A faster CPU. Genuinely last. It will not make the machine generate tokens faster.

The upgrade that is not on this list is a second graphics card. Splitting a model across two cards works and is how people reach 70B-class models at home, but it brings power delivery, physical spacing and motherboard lane allocation problems that are better solved by planning for them at build time than by retrofitting. That is a different architecture, not an upgrade to this one — and it is specified separately in the dual-GPU 70B machine. If you expect to get there in stages rather than at once, the staged-upgrade PC covers what to over-specify now so the option survives.