Lokale large language models voelen in het begin razendsnel aan. Je laadt een model met 7B of 13B parameters, voert een korte prompt uit, en tokens stromen op een prettig tempo over het scherm. Dan plak je een lang codeblok, of je chatgeschiedenis zwelt aan over een dozijn beurten, en het model begint te kruipen. De vertraging is zelden geleidelijk. Het is een afgrond. Het ene moment produceert de GPU tokens; het volgende moment laat je systeemmonitor zien dat de geheugendruk toeneemt en de generatie vertraagt tot een hapering. Je kunt niet met een simpele formule voorspellen wanneer dit zal gebeuren. Je enige betrouwbare gids is de hardware zelf.

De verborgen kosten van context

Elke token die je genereert, voegt een status toe aan de KV cache. Deze cache slaat de keys en values op die zijn berekend tijdens de prefill- en generatiefases, en deze bevindt zich in het geheugen naast je modelgewichten, attention buffers en runtime overhead. Op een typische consumenten-GPU met 12 GB of 16 GB VRAM moet de KV cache uiteindelijk strijden om ruimte met de rest. Wanneer het dedicated videogeheugen vol raakt, geeft het besturingssysteem geen foutmelding en stopt het niet. Het laat de overloop stilletjes naar het gedeelde geheugen lekken, waarbij data tussen de GPU en het systeem-RAM wordt verplaatst via de PCIe-bus. Die bus is snel voor bestandsoverdrachten, maar is traag vergeleken met de geheugenbandbreedte binnen een videokaart. Het resultaat is geen kleine dip in prestaties. Het is een instorting.

Drie signalen dat de afgrond is bereikt

Houd je hardwaremonitoren in de gaten terwijl het model draait. Je zult drie duidelijke signalen zien zodra de prestatieafgrond wordt bereikt.

  • Shared VRAM stijgt. Dit is geheugen dat de GPU-driver uit het dedicated videogeheugen naar de pool heeft verplaatst die wordt beheerd door het besturingssysteem. Zodra deze metriek boven nul stijgt, heb je de grens overschreden.
  • Systeem-RAMgebruik zwelt aan. De overloop moet ergens terechtkomen, en die bestemming is je hoofdgeheugen. Als je RAM-gebruik groeit terwijl het model tokens genereert, wordt er data van de GPU afgevoerd.
  • Eval-snelheid daalt met de helft of meer. Een vertraging van 10% kan duiden op thermal throttling of achtergrondprocessen. Een daling van 50%, of zelfs meer, betekent dat de bottleneck is verschoven van tensor cores naar geheugenbandbreedte en PCIe-latentie. Wanneer je ziet dat de generatie van dubbelcijferige naar enkelcijferige waarden daalt, ben je de afgrond al in gevallen.

Waarom je snelle benchmark waarschijnlijk liegt

Een korte smoke test geeft je een vals gevoel van vertrouwen. Als je het model benchmarkt met een prompt van honderd tokens, een gezonde doorvoer ziet en klaar bent, dan heb je alleen de huwelijksfase gemeten. De KV cache is bijna leeg. De lagen zijn niet belast door een lange prefill. De werkelijke voetafdruk laat zich pas zien nadat het model een substantiële prompt heeft verwerkt en de cache is gevuld tot de werkelijke werkcapaciteit. Je moet testen met een diepe prefill en lange generatieruns. Laat de context daadwerkelijk accumuleren. Pas dan zal de geheugendruk stabiliseren en de werkelijke limiet laten zien.

Je limiet vinden met llama.cpp

Als je modellen draait via llama.cpp, kun je je grens meten met eenvoudige rekenkunde en een geduldige testrun.

1. Meet het gedeelde geheugengebruik.
Noteer je basislijn van het dedicated VRAM met een minimale prompt, voer vervolgens een taak met een lange context uit en noteer de piek. Trek de basislijn af van de piek. Het verschil is wat er uit je GPU naar het gedeelde systeemgeheugen is gelekt.

2. Bereken je RAM-delta.
Doe dezelfde aftreksom voor het systeem-RAM. Trek je basislijn-RAM af van het piek-RAM tijdens de lange run. Dit getal vertelt je precies hoeveel data van de videokaart naar je hoofdgeheugen is verplaatst. Het kwantificeert het lek over de bus.

3. Meet de instorting van de eval-snelheid.
Vergelijk je basislijn tokens-per-seconde met de snelheid nadat het model een lang document heeft verwerkt. Je ziet misschien een model dat met zeventien tokens per seconde doordendert wanneer de context vers is, om vervolgens slechts twee tokens per seconde te leveren zodra de cache is opgezwollen. Die daling van vijftien tokens is je 'canary in the coal mine'.

Het breekpunt trianguleren

To map the curve accurately, do not settle for one lonely data point. Run three distinct trials at 16,000 tokens, 32,000 tokens, and 65,000 tokens. Two points might suggest a line, but two dots are just a guess. The third point proves whether you are looking at measurement noise or a real memory wall. Subtract the results between runs to calculate how much extra memory each additional thousand tokens consumes on your specific combination of model, quantization layer, and GPU.

Once you have that slope, you can project forward. Take your per-token cost, multiply it by the target context length, divide by 1024 to move between units, and add the result to your base model VRAM load. The equation looks like this:

Model VRAM load + (tokens × memory per token ÷ 1024) = Theoretical VRAM usage

This projection is not prophecy. It is a guidepost derived from actual behavior. Use it to estimate your ceiling before you commit to a full production run.

Why Paper Formulas Fail, and What Quantization Can Fix

Textbook formulas ignore the messy reality of local inference. Different architectures allocate attention buffers differently. Your operating system reserves VRAM for the display driver, compositor, and CUDA context. Driver versions change how aggressively they use shared memory. A theoretical equation cannot know how much VRAM is actually free on your machine at 2:00 PM with a browser full of tabs open. You have to run the model on your specific hardware and watch the meters.

Quantization offers partial relief. Moving the KV cache from f16 to q8_0 halves its memory footprint while keeping precision high enough for nearly all practical tasks. That change buys you headroom. It does not grant immunity. The cache still grows linearly with every token you feed in. Eventually, even the reduced size overwhelms your available dedicated memory and the spillover to system RAM begins. The pressure only stops when the context window is capped or the data stops moving.

The Real Takeaway

Do not trust marketing slides, parameter counts, or back-of-the-envelope math. Load the model. Open your system monitor. Run a 65,000-token thread, watch the RAM climb, and count the tokens per second. The numbers that appear on your specific screen, on your specific GPU, are the only numbers that matter. Context always wins. Your job is to know exactly when it wins on your machine.