TL;DR
Agent development is API orchestration, not model training. What specs actually matter, when local inference changes the answer, and where to spend instead.
→ See how this applies to your business (free 30-min call)Someone asks this question about once a week, usually right before spending four thousand dollars they didn't need to spend. So let's start with the answer and then justify it: for the overwhelming majority of agent development, the machine you already own is fine, and the useful upgrade is 32GB of RAM.
The reason is architectural. Building AI agents is not training AI models. An agent is orchestration code — it makes HTTP requests to a model provider, parses responses, calls tools, manages state, and handles failures. That workload is I/O-bound and memory-bound. It is not GPU-bound, because the GPU doing the work is in someone else's data center.
People conflate these two activities constantly, and the hardware industry has no incentive to correct them.
What the Work Actually Looks Like
Spend a day building an agent and here's where the time and the resources go:
Notice what's missing: any sustained parallel numerical computation. That's the thing GPUs are for, and it isn't happening.
If your agent's inference runs in a data center, your laptop's job is to be a comfortable place to write code and read traces. Buy for that.
The Specs That Genuinely Matter, Ranked
RAM — 32GB. This is the one real requirement. Between containers, a language server, a browser, and a local database, 16GB starts swapping and your machine feels slow in a way that has nothing to do with your CPU. 32GB is the difference. 64GB is worth it only if you run large local models or heavy virtualization.
A fast SSD, 1TB. Dependency trees are enormous. Docker images are enormous. Model weights, if you ever download any, are extremely enormous. Running near-full is a real source of misery, and external drives don't help with build times.
Battery and thermals. Unglamorous and the thing you'll actually notice daily. A machine that throttles under a long build, or that dies in the afternoon, costs you more real productivity than any benchmark difference.
Screen real estate. You will constantly have code, a trace viewer, and documentation open simultaneously. A larger display or a second monitor is a bigger productivity gain than a faster processor.
CPU. Any modern mid-tier chip is sufficient. Apple Silicon, recent AMD, recent Intel — all fine. This is the spec people optimize and it matters least.
A discrete GPU. Only relevant if you're running local inference. See below.
The Case Where Local Inference Changes the Answer
There are legitimate reasons to run models on your own hardware, and if any apply to you, the calculus shifts:
For local inference, the binding constraint is memory available to the accelerator, because the model weights must fit. Apple Silicon's unified memory architecture is unusually well-suited here — a Mac with 48GB or more of unified memory runs mid-sized quantized models comfortably, which is a capability that would require an expensive discrete GPU on a PC.
On the Windows and Linux side, laptop GPUs are memory-constrained relative to their desktop equivalents at the same tier, and they throttle under sustained load. Which leads to the recommendation most people don't want to hear.
Buy a Modest Laptop and a Desktop or a Cloud GPU
If you genuinely need serious local inference, a laptop is the worst way to buy it. The same money spent on a desktop with a high-VRAM card gets you substantially more capability, better sustained performance, and an upgrade path. Then you SSH into it from a light laptop.
Cheaper still: rent. A cloud GPU instance costs a few dollars an hour and you pay only while you're using it. Unless you're running inference many hours a day, every day, renting wins on total cost — and you can pick a bigger card for a hard week without buying it forever.
Three Concrete Configurations
The default — roughly $1,600 to $2,200. A current-generation ultraportable with 32GB RAM and a 1TB SSD. Apple's mid-tier machines, a well-specced ThinkPad, or a Framework. This covers the entirety of agent development against hosted APIs. If you're not sure what you need, this is the answer.
The local-inference machine — roughly $3,000 to $4,000. Apple Silicon with 48GB or more of unified memory. The unified architecture is the specific reason to choose this over a similarly priced Windows machine; you get access to model sizes that discrete laptop GPUs can't hold.
The split setup — roughly $1,200 laptop plus $2,000 desktop, or $1,200 plus cloud. A light, long-battery laptop for writing code, and a desktop with a high-VRAM GPU sitting at home doing the heavy lifting. Best performance per dollar by a clear margin, at the cost of some setup complexity.
Notice that the default configuration is the cheapest, and it's what most people should buy.
Mac, Windows, or Linux — Practically
The operating system question matters more than the hardware question, and for boring reasons.
macOS. The default for most agent developers because the tooling assumes a Unix environment and the hardware is efficient. Unified memory makes local inference viable at sizes that would need an expensive discrete GPU elsewhere. The downside is cost and non-upgradeable RAM, which makes the 32GB decision permanent at purchase time.
Linux. The environment your code will eventually run in, so developing there removes a class of "works on my machine" problems. Best GPU support for local inference, and full control. Costs you some time on hardware compatibility and battery management on laptops.
Windows with WSL. Genuinely fine now, and the pragmatic choice if you also need Windows for other work. You get a real Linux environment for development plus native GPU access. The friction is filesystem performance across the boundary — keep your projects inside the Linux filesystem, not on the Windows side, or builds will crawl.
The recommendation: pick the one you're already fast in. The productivity difference between operating systems is small compared to the productivity difference between a tool you know and a tool you're learning while also learning agent development.
Where Your Money Is Actually Better Spent
Having built and shipped agent systems in production, here's the honest ranking of what improves outcomes:
The Uncomfortable Truth About Building Your Own
If you're a business owner asking this question because you're planning to build the agents your company runs on, there's a prior question worth answering: should you be building them at all?
For revenue-critical, latency-sensitive paths — inbound lead response, qualification, booking — the requirement is uptime, sub-two-minute response, and conversation quality under real conditions. That's an operations problem more than an engineering one. Our AI callers reach every inbound lead within 90 seconds, day or night, and hand qualified prospects to a human with the full context attached. Nobody on our client side owns a GPU.
For internal tooling — a research agent over your own documents, a reporting agent, an operations triage bot — building is often the right call, and the $1,800 laptop will handle it.
The Recommendation
Buy 32GB of RAM and a 1TB SSD in whatever brand you like using. Add a second monitor. Spend the money you saved on evaluation runs and observability. Revisit the GPU question only when you have a specific, written reason you need local inference.
If you'd rather have the agent systems that drive revenue built and operated for you instead of building them yourself, [book a free strategy call](/book) and we'll show you what that looks like.
Free Weekly Briefing
One AI Marketing Tactic.
Every Tuesday. Free.
What's actually working across our client accounts right now — ROAS moves, follow-up sequences, creative angles. The stuff that isn't in any blog post yet.
No spam. Unsubscribe anytime. 1,200+ business owners already in.