What Hardware You Actually Need to Run AI Agents

Job one: the agent layer, which runs on almost anything

An agent is a program that reads files, runs commands, and calls a model to do the thinking. When that model lives in the cloud, your machine only runs the program part, and the program part is light. Claude Code's published system requirements, as of September 2026: 4 GB or more of RAM (RAM is the computer's general working memory), an x64 or ARM64 processor, and an internet connection. It runs on macOS 13+, Windows 10 (1809)+, and mainstream Linux. There is no GPU requirement anywhere in the docs, and the native install is a standalone binary, so you do not even need Node.js at runtime.

The same shape holds whichever CLI (command-line interface, a text-only program you type commands into) you build on; the system we teach is agent-agnostic. The heavy computation happens on the provider's servers and is metered in tokens (the small chunks of text a model reads and writes, and the unit AI usage is billed in) over an API (a paid service you call over the internet). Your machine coordinates. Their machines think.

Practical translation: the 4 GB floor means nearly any laptop, desktop, or mini PC from the last eight years or so runs the agent layer. If you own a computer that can browse the web comfortably, you already own the hardware for a multi-agent system. What that system costs to operate is a token question, not a hardware question, and we published our own meter readings in what running AI agents actually costs. This article is that one's companion: it covers the only case where hardware money enters the picture.

Job two: local inference, the only part that wants hardware

Local inference means the model itself runs on your machine instead of a provider's. Why bother, when the cloud path needs nothing? Two reasons we consider real. First, tokens: every task a local model absorbs costs zero marginal tokens, and in our own published cost data, 20 routine tasks in a 54 day window ran locally at zero marginal cost. Our factory pairs a paid cloud model for hard problems with a free local model, a roughly 9B qwen (9B means nine billion parameters, the numeric weights that make up a model; the count is shorthand for its size), for routine work, and only the narrow, templated kind; anything that needs judgment goes to the paid model. Second, ownership: a local model keeps working, and keeps your data home, no matter what a provider changes.

The honest caveat is capability. Small local models handle routine, well-specified tasks; they do not replace frontier models for hard ones. We wrote up which model sizes actually hold up in agent work separately. The point here: local inference is an optimization you add when the token math invites it, not an entry requirement.

How much memory each model size needs

Model memory needs scale with parameter count. The numbers below use the published guidance of Ollama (a free, open-source program that runs models on your own machine), printed on its model library pages, plus the download sizes of current models at Ollama's default quantization (quantization compresses a model's weights to lower numeric precision so they fit in less memory, at a small quality cost). The download size approximates the memory the weights alone occupy; context adds more on top.

Where the model sits matters as much as whether it fits. Inference is quick when the weights fit in VRAM (the dedicated memory on a graphics card) and slower on CPU and system RAM. llama.cpp, the engine under most local tooling, documents hybrid CPU plus GPU inference for models bigger than your VRAM, so partial fit degrades speed rather than failing outright. LM Studio, a popular desktop app for local models, recommends 16 GB of RAM and, on Windows, a GPU with at least 4 GB of VRAM. Apple silicon Macs are a special case worth knowing about: they use unified memory (one pool shared by the processor and graphics, so system RAM is the model memory, with no separate VRAM budget), and llama.cpp treats them as a fully supported target. A 24 or 32 GB Mac can hold model sizes that need a 24 GB graphics card on the PC side.

What the hardware costs, and what it burns

First, the 2026 caveat: this is a bad year for cheap-hardware advice. The memory chip shortage driven by AI datacenter buildout pushed RAM and prebuilt prices up across the board, and used high-VRAM GPUs appreciated instead of depreciating. Verified anchors, with dates:

RTX 3060 12 GB, new: $339. This card returned to retail as new stock in 2026, and Tom's Hardware reported a Newegg listing at $339 (checked September 2026). Its 12 GB of VRAM holds the 8B tier with room to spare. NVIDIA rates it at 170 W of graphics card power (a watt is the rate a device draws electricity) and recommends a 550 W power supply for the system.

RTX 3090 24 GB, used only: budget with care. NVIDIA rates it at 350 W with a 750 W system recommendation, and its 24 GB reaches the ~30B tier. Price-aggregator sites, which we have not independently re-verified, put recent eBay sold-listing averages around $900 to $1,050, and the direction matters more than the number: 3090 prices rose through 2026 as AI demand chased 24 GB cards. The era of the cheap used 3090 is over. Check current sold prices yourself before budgeting around one.

Electricity: small for agents, real for sustained inference. The EIA forecasts the average US residential rate at about 18 cents per kWh for 2026 (a kilowatt-hour, kWh, is the unit on your power bill: one thousand watts drawn for one hour). Our arithmetic from the published wattages: a 350 W GPU under load 8 hours a day is about 84 kWh a month, about $15 for the card alone. NVIDIA publishes no idle figure, so the standing cost of a GPU tower left on is an estimate: community measurements put a whole idle tower at roughly 50 to 80 W, which works out to roughly $6 to $10 a month, an estimate built on measurements, not a spec sheet. For contrast, Apple publishes idle draw for the 2024 Mac mini M4 at 4 W measured at the wall, about $0.52 a month at the same rate. That gap is the hardware split in one line: the agent layer idles for cents; sustained local inference is where the meter moves.

The order of operations

Here is the sequence we would follow starting today, and it is the sequence the factory actually followed:

1. Run the agent layer on the machine you already own. The floor is 4 GB of RAM. Nothing to buy.

2. Pay for cloud tokens and watch the meter. Our whole 54 day window read about $265 at API-equivalent rates, most days under $2, and the cost breakdown shows where it goes.

3. If the meter shows routine work a small model could absorb, try an 8B on hardware you already have. An 8 GB machine meets Ollama's stated minimum for that tier; 16 GB leaves room for context and everything else you run. Try it and judge the speed yourself. Free experiment, honest verdict.

4. Buy hardware only when the token math says so. A $339 GPU has to displace a lot of cloud tokens before it pays back, and it only displaces the work a small model can actually do. If your meter reads a few dollars a day, the payback case is thin. If local routine work is already earning its keep on borrowed hardware, the case writes itself.

The system scales to the hardware you give it, not the other way around. Start with what you own, meter everything, and let the numbers make the purchase decision. In 2026 pricing, the numbers argue for patience more often than for a checkout cart.