The Model Fits in 8GB; the Agent Needs Far More

The pitch for local AI on a gaming PC usually gets argued in model sizes — which quantization fits which card, how many tokens per second come out. That framing is off by one variable. An agent spends context before your task even starts: system prompt, tool definitions, skill documentation, behaviour rules. The number that decides whether a card can do the job isn't how large a model it holds, but how much context it can afford to keep resident beside it.

Context Is the Real Budget

The hardware was deliberately ordinary: 8, 12 and 16 GB Blackwell cards, the three most common VRAM capacities in the August 2026 Steam hardware survey, on a Core Ultra 9 285K bench with everything kept inside VRAM. The models were Gemma 4 in two sizes — E4B at Q8_0, 8.03 GB, on the 16 GB RTX 5060 Ti with a 131,072-token window; E4B at Q6_K, 6.33 GB, on the 12 GB RTX 5070 with 65,536; and E2B at Q8_0, 4.97 GB, on the 8 GB RTX 5060 with 131,072.

The asymmetry is the point. The 16 GB card runs the same model family at higher precision than the 12 GB card and gives it twice the context. The 8 GB card doesn't get E4B at all: a Q4 build left no room for even a 64k window, which is the floor the harness enforces before it will open a session. So it drops a tier in parameter count to buy context back. That is the trade every 8 GB owner is making whether they know it or not — less brain, more working room.

Every extra token costs KV cache, and an agent's window fills faster than a chat session's because the harness keeps talking to itself. A 64k budget sounds generous until a tool-heavy task has five rounds of reasoning plus a system prompt describing every available tool sitting in it at once. Model size is the number printed on the box. Context is the number that decides what the agent can actually finish.

Where the Ladder Breaks

Eight tasks, all things a new owner would plausibly try: hold onto a name and a set of behaviour rules, find a lactose-free cheesecake recipe, research why RAM and SSD prices climbed, write an FFmpeg script that stitches two videos side by side, write a CSV profiler tested against twelve files including deliberately malformed ones, set up email through Himalaya and summarize a recurring newsletter, deploy Plex in Docker, and stand up Home Assistant then toggle its lights.

The 16 GB card cleared six of eight outright and earned two partials. The 12 GB card finished one behind, losing some sharpness on the way — it printed an email password into the chat log instead of using the credentials it had been handed, and it reported sunset in UTC without noticing that 3:29 AM is not an evening. The 8 GB card passed the recipe search and essentially nothing else. It wrote nothing to memory until told to, generated synthetic DRAM and NAND price series for the research report and then never included them, scaled each video to 3840 pixels wide instead of 1920 in the FFmpeg job, repeated the same error after a correction, and at one point declared that further script edits would be unproductive.

The result that should bother everyone's assumptions is the coding pair. The small, obvious FFmpeg job failed at all three tiers — a wrong codec flag on the 12 GB card, a shortest-length trim documented in the script's own comments but missing from the actual command on the 16 GB card, broken scaling on the 8 GB card. The larger CSV profiler, with a dense prompt spelling out requirements and edge cases, came out working on both the 16 GB and 12 GB cards after a few self-corrections with no human intervention. Prompt detail did more for the smaller models than extra parameters did. Email was the opposite story: search and summarize failed at every tier, which looks like a model-family ceiling rather than a VRAM one.

Spilling Into System RAM Buys Size and Sells Speed

The escape hatch is offloading part of the model into system memory, which llama.cpp-based servers including LM Studio and Ollama will do without complaint. It works, and it doesn't make the model dumber — the same weights at the same precision give the same answers whether they sit in VRAM or DDR. It makes them slow by a margin that turns a task into an afternoon. If the plan is to leave an agent grinding while you get on with something else, that's a legitimate trade. If the plan is to sit and watch it work, you will go back to the cloud.

Which lands on the framing that actually makes sense. The card is idle most of the week. Between sessions it can hold a small model with a real context window and do useful, unglamorous work for the cost of the electricity: batch document summaries, script generation, local search across your own notes. What it can't do at 8 GB is be a generalist that handles an eclectic mix of problems. That is not a tuning problem a better quantization will solve, and pretending otherwise is how people end up disappointed in hardware that was never going to clear the bar.

What I Think

The advice that is uncomfortable and probably right: 8 GB is enough hardware to learn on and not enough to depend on. The honest use of that card is narrow, well-prompted, single-purpose automation — a workflow where you write the instructions carefully once and it runs the same shape of task forever. That is genuinely valuable, and it is not an agent that works out what you meant.

What should change how people buy is the context floor, not the model size. 12 GB is where the trade stops hurting: the bigger model at a sane quantization, just over the minimum window, and enough room to run a task spread without babysitting every step. 16 GB buys headroom that shows up as reliability rather than intelligence. On a machine that will mostly play games and occasionally hold an agent, moving up a VRAM tier does more for what you can actually run than a faster CPU will. And if you already own the 8 GB card, don't buy a GPU to fix this — write a better prompt first, then buy once and buy properly.