The short answer: yes. Pretty much any computer from the last several years can run a local AI model. The smallest ones are under a gigabyte and run on very ordinary hardware.
But that’s not the real question. The real question is: can my computer run a local AI model that does what I want it to do?
And that comes down to three things:
- The complexity of your task. Generally, the more complex the task, the larger the model you need to do it well.
- How much memory your computer has. This determines how large a model you can run.
- How much compute your computer has. This, together with memory, determines how fast it runs.
The rest of this guide shows you how to answer each of these for your task and your computer specifically, including how to read your own machine’s specs (two clicks on a Mac, three steps on a PC). (Our main guide has the 60-second version and walks you through running your first model; our free readiness checker does the math for you in under a minute.)
What Size Model Does Your Task Need?
Models come in sizes, and the size is right in the name: Gemma 4 12B means 12 billion parameters, roughly how big the model’s brain is. Within the same model family, larger usually means more capable. Match your task to the smallest size that handles it; bigger than that costs memory and speed for nothing. Here’s what to expect at each level:
- Around 1B (featherweight): quick answers, cleaning up text, simple drafting. Fast even on modest machines. It will lose the thread on complex requests, and that’s fine; it’s the gateway, not the destination.
- 4B to 8B (the everyday class): real assistant work: drafting and rewriting, summarizing, brainstorming, answering questions about text you paste in. This is where local AI starts feeling like a real assistant, and it’s the sweet spot for most people.
- 12B to 27B (the step up): noticeably better nuance, longer documents, more reliable reasoning. Wants serious memory.
- 30B and up: the most capable open models, at their best on the hardest work: long documents, careful reasoning, demanding writing. High-end machines only.
Two things to hold onto. Bigger is never free: a bigger model needs more memory and runs slower on the same machine. And a well-matched smaller model often beats a too-big one in practice, because an answer that arrives quickly from a model that fits comfortably is worth more than a slightly better answer you wait ages for.
Beyond chat: coding, agents, and images
- Coding follows the same ladder. The 4B to 8B class is genuinely useful for explaining code, writing snippets, and autocomplete; dependable help on real projects starts around 12B.
- Tool calling and agents (AI that takes multi-step actions for you) has two requirements. The model must support tools (model pages list capabilities like “tools” and “thinking”; look for the tags), and reliability climbs steeply with size: small models can call a tool, but carrying a multi-step job without losing the plot is 12B-and-up territory. Agent work also burns through context, which burns memory (more on that below).
- Understanding images (showing it a screenshot or a photo) is a listed capability, “vision,” available at many sizes.
- Generating images or video is a different kind of model entirely; the chat models in this guide don’t do it. Local image generation has its own apps and leans hard on a dedicated graphics card, and local video generation is barely practical on ordinary computers today. If creating images or video is your main goal, this article’s tables aren’t your map.
How Big a Model Will Your Computer Run? Memory.
A local AI model is a file that loads into your computer’s memory to run. If it fits with room to spare, it runs at full speed. If it’s too big, most tools will still limp it along by spilling the overflow into slower memory, but you won’t enjoy the result (the speed section below shows what that feels like). That’s why memory, not processor speed, is the spec that decides what your machine runs well.
Where that memory lives depends on your machine:
- Macs with Apple Silicon have one shared pool called unified memory that the whole computer draws from, model included.
- PCs with a dedicated graphics card run models best in the card’s own memory, called VRAM.
- PCs without a dedicated card run models on the processor using regular RAM: workable, slower.
Checking your machine: easy on a Mac, three steps on a PC
On a Mac: Apple menu → About This Mac. If the chip line says M1, M2, M3, or later, you’re set: the “Memory” number is your number. If it says Intel, local AI isn’t practical on that machine beyond small experiments; a cloud model is the better bridge until your next computer.
On a Windows PC, it takes three steps, because you first need to find out whether you have a dedicated graphics card (many computers don’t, and plenty of owners genuinely don’t know):
- Press Ctrl + Shift + Esc to open Task Manager, then click the Performance tab (the small graph icon in the left sidebar).
The one trap: Task Manager also shows a “Shared GPU memory” number, and it’s usually the bigger one. Don’t read it as VRAM. That’s ordinary RAM the system is willing to lend the graphics chip, much slower than dedicated memory, and it’s the most common way people overestimate their machine.
The rule of thumb: matching a model to your number
Take the model’s size number, multiply by three-quarters, and add one. That’s roughly the gigabytes of memory it needs.
So a 4B model needs about 4 GB. A 12B model needs about 10 GB. A 27B model needs about 21 GB. To be clear about what this is: it’s the deliberately conservative estimate our checker uses, and it assumes the standard compressed versions you’ll download from Ollama (a common four-bit format), one model at a time, and an ordinary chat. Unusual setups move the number; for picking a starter model, this rule keeps you safely inside your machine.
Two adjustments before you compare that to your own number:
- On a Mac, your usable share is smaller than the sticker. Unified memory is shared with everything else your computer is doing, so divide by about 1.4: a 16 GB Mac has roughly 11 GB of usable model room. (A cautious convention, not physics; it’s how our checker leaves room for everything else your Mac is doing.) It also works in reverse when reading advice online, which is usually written in PC terms: “you need 16 GB of VRAM” translates to roughly 40 percent more unified memory, so 22 GB, meaning buy 24.
- Leave breathing room. A model that fits with about 20 percent of your memory to spare runs comfortably. A model that barely squeezes in will load, then disappoint you (the speed section below shows you exactly how).
One exception to the rule of thumb: some models come in extra-compressed compact builds whose real footprint is much smaller than their name suggests (Gemma 4’s “E” sizes are like this). For those, go by the listed download size, not the name, and treat the download as the starting footprint: your conversation still needs working room on top.
What runs at each memory level
Here’s the rule worked out, using Google’s open Gemma models as the yardstick, the same recommendations as our main guide and our checker. These are curated starter picks, not your machine’s ceiling; the checker shows the full size range your memory supports.
On a Mac (unified memory):
| Your unified memory | Comfortable starter model | Download size |
|---|---|---|
| 8 GB | Gemma 3 1B | under 1 GB |
| 16 GB | Gemma 4 E4B (compact) | about 6 GB |
| 32 GB | Gemma 4 12B | about 8 GB |
| 48 GB | Gemma 4 26B | about 18 GB |
| 64 GB+ | Gemma 4 31B | about 20 GB |
On a PC (graphics-card VRAM):
| Your VRAM | Comfortable starter model | Download size |
|---|---|---|
| 8 GB | Gemma 4 E2B (compact) | about 4 GB |
| 12 GB | Gemma 4 E4B (compact) | about 6 GB |
| 16 GB+ | Gemma 4 12B | about 8 GB |
A 24 GB card runs the 12B with lots of headroom and can stretch to the 18 GB Gemma 4 26B. On integrated graphics, the cap from step 3 applies instead: about 3B comfortably, 7B if you’re patient, whatever your RAM.
Two notes on the edges. At 8 GB on a Mac, the compact Gemma 4 E2B (4 GB) is a popular stretch pick if you keep other apps closed; the comfortable answer is still Gemma 3 1B. And below 8 GB, a cloud model can cover the heavy lifting while you learn. You don’t have to choose one world or the other.
This is the same math the free readiness checker runs for your exact machine: enter your memory, get a verdict, a size range, and a starter model. It runs entirely in your browser and sends your specs nowhere. (We’re biased, we build BrainDrive; the checker is free and works whether or not you ever use anything else of ours.) And our complete local AI guide for non-developers gives the exact one-line command to run any of these.
How Fast Will It Run It? Compute.
Speed for local AI means how fast words appear. A model running comfortably answers like a fast typist: the response starts within a second or two and flows steadily. That’s what a well-matched model feels like even on modest hardware, and it’s genuinely pleasant.
What sets the pace, in order:
- Whether the model fits with room to spare. Fit comes first: a model straining against your memory limit is slow no matter what processor you have. Most local AI tools will quietly spill an oversized model into slower memory rather than refuse to run it; it works, at a real speed cost. Treat the spillover as a safety valve, not a plan.
- Your accelerator, and how fast it can read memory. Once a model fits, the graphics processor sets the pace, and so does the speed of the memory it’s reading from: generating text is as much about moving the model’s numbers around as crunching them. This is why the same model feels brisk on a dedicated card and leisurely on integrated graphics, whose borrowed system memory is far slower. On Apple Silicon, the built-in graphics and fast unified memory do this job well. (Some apps can accelerate integrated chips these days; treat that as a bonus if you get it, not something to count on.)
- Context: the slow leak. The model’s context is how much conversation and document text it’s holding in mind, and it eats memory as it grows. This is the one people miss: the model chats happily for a week, then crawls the day you paste in a 50-page document. Nothing broke; the context grew past your spare room. Plan for how you’ll use it, not for whether it loads.
- RAM and drive, the supporting cast. System RAM and a fast drive decide how smooth everything around the model feels: how fast models load, how responsive the machine stays while you work. They rarely decide success, but skimping shows.
Signs you’re over your machine’s limit, in the order you’ll meet them: slow to load but fine after (harmless, big file); fast in short chats but painful in long ones (context); words trickling out one at a time (spillover, model too big); won’t load at all (past the limit, go smaller or compact).
Is an “AI PC” What You Need for Local AI?
Shop for a computer right now and you’ll be buried in “AI PC” and “Copilot+ PC” branding, usually pointing at a chip called an NPU with an impressive-sounding TOPS number.
Here’s the distinction that matters: an NPU is not yet a dependable way to run the models you choose. NPUs can run some specially optimized models, and they shine at built-in operating-system features like live captions and photo search. But support is fragmented: whether your app can run your model on one is a lottery, and the free apps most people use (Ollama, LM Studio, BrainDrive) lean on your GPU and your memory today. A laptop can carry the “AI PC” sticker and be mediocre at local AI; a sticker-free machine with plenty of memory can be excellent.
The practical test is one question: how much memory does it have? Treat the NPU as a bonus, not a buying criterion.
If Your Computer Comes Up Short
Work the options in order of cost:
- Go smaller. A compact build or a smaller model keeps you in the game on the machine you own. The featherweights are better than you’d think for everyday drafting, summarizing, and Q&A.
- Borrow the cloud for the heavy moments. Run local for the private everyday work, reach for a cloud model when you need more horsepower. You don’t have to choose.
- Upgrade or buy, matched to your wall. Each symptom maps to one spec: won’t fit means memory (VRAM or unified), flows too slowly once loaded means graphics processor, everything around it feels sticky means RAM and drive. On many PCs, RAM and storage are cheap upgrades; VRAM and Mac memory are not upgradeable, which makes those a buying decision.
When you get to option 3, that’s a different question than this article answers, and it deserves its own guide: Best Computer for Local AI (coming soon) covers Mac vs. PC, graphics-card tiers, what to spend, and a pre-buy checklist.
One thing most people miss: everything in this article is about the model, and the model is the most replaceable part of your AI system. Today’s best gets beaten monthly. The parts that are uniquely yours, and the ones most worth keeping local, are your context (everything your AI knows about you and your work) and your interface (the system you work in). Here’s the good news: those are featherweight. They run on any computer in the tables above, including the ones that came up short. This is what BrainDrive, the user-owned AI system we build, is designed around: your memory and interface live on your machine and stay yours, while the model behind them is swappable: local when your hardware allows, cloud when you need the horsepower. Your computer rations which models you can run locally. It doesn’t ration ownership. (The full argument is in our main guide.)
BrainDrive pointed at a local model: the interface and memory live on your machine; the model behind them is swappable
You don’t need the perfect machine. You need to know what the one in front of you can do, and now you can work that out yourself.
Common Questions About Computers for Local AI
Do I need a powerful computer for AI?
No. A five-year-old laptop with 8 GB of memory can run compact models today. Powerful hardware buys you bigger models and faster responses, not entry.
How much RAM do I need for AI?
8 GB is the floor, 16 GB is a comfortable start, and 32 GB gives you room for bigger models and document work. On a Mac, unified memory is shared with everything else, so lean one tier higher.
What PC do I need to run AI?
Any recent PC with 8 GB of RAM runs the small models on its processor (stay around 3B or below there). A dedicated graphics card with 8 GB or more of VRAM is what makes them fast and raises the ceiling on size; with a card, use the rule of thumb above to match your VRAM to a model.
Is a Copilot+ “AI PC” what I need for local AI?
No. That branding is about NPU-accelerated operating-system features. The models you’d run yourself lean on your GPU and memory today; judge a machine by those.
Mac or PC, which is better for local AI?
Both run local AI well. Macs keep it simple with one shared memory number; PCs with a dedicated graphics card put the model in fast VRAM. Which to buy is a different question; we cover it in Best Computer for Local AI (coming soon).
Where to Go Next
- Check your machine: the local AI readiness checker runs this article’s math for you in under a minute.
- Run your first model: Local AI for Non-Developers: The Complete 2026 Guide walks you through it step by step.
- Understand the models themselves: Best Local AI Models, in Plain English (coming soon).
- Ready to buy? Best Computer for Local AI (coming soon) turns this knowledge into a purchase decision.
- Go deep on hardware: our full 11-lesson course, How to Choose a Computer for Local AI (coming soon).