De shop is live

Wij bouwen Workstation AI-machines voor websites, AI-agents en LLM-training — configureer en koop online.

Bekijk handelsprijzen
AI-producten
AI LabsOpenAI-agentsClaude-agentsGrok-botWorkstation AI native CRMMarketingAlle producten
AI-oplossingen
Toegepaste AIAI-agentsGeneratieve AIAI-automatiseringAI-bijscholingAI-pakketten voor het mkbEnterprise AI LabAI-werkstationsNVIDIA-hardware en -softwareNVIDIA Accelerated ComputingPrivate AIGPU private cloudGPU-clustersEdge AIAI per sector
AI-diensten
PlatformmoderniseringDigitale engineeringDatafundamenten en AIAutonome operatiesAI-adviesDevOps-automatiseringCybersecuritySoftwareontwikkelingAgentontwikkelingMLOps-opzetGPU-leasingGPU private cloud
Over ons
BedrijfOns verhaalPartnersKlantverhalen
AI-datacenters
AI-datacentersGPU private cloudGPU-clustersGPU-leasing
AI-inzichtenJev-reeksBenchmarklabModelkeuze
Technische notities
Documentatie
Linux-OSUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
AI-cloudplatformsAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryGPU-clouds en -marktplaatsen
Private AI-datacentersVoor advocatenkantorenVoor accountantskantorenOn-premises platformsVolledig beveiligde cloud
ToolsRing PromoterJobshout
Nieuws
Blog
Neem contact opInloggen

AI-werkstations, AI multi-agent software, GPU-infrastructuur en intelligente agentoplossingen voor moderne bedrijven.

Neem contact op

AI-oplossingen

Toegepaste AIAI-agentsGeneratieve AIAI-automatiseringAI-bijscholingAI-pakketten voor het mkbEnterprise AI LabAI per sector

Producten

Alle productenWorkstation AI-native CRM & ERPMarketingOpenAI-agentsRing PromoterJobshout

Bedrijf

Over onsBedrijfAI-datacentersWaarom WorkstationPartnersKlantverhalenPrijzenContactTenthMatrix

Bronnen

AI-inzichtenTechnische notitiesDocumentatieLinux-OSAI-cloudplatformsPrivate AI-datacentersBlogZoekenSitemap
Kantoor België
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Ma - Vr: 9:00 - 18:00 CET
+32 492 45 67 46
Hoofdkantoor VK
77-79 Marlowes, Hemel Hempstead HP1 1LFRoute: neem afrit 20 van de M25, Outer LondonBedrijfsnummer: 11641870Ma - Vr: 9:00 - 18:00 GMT
+44 7515 356 146
Kantoor India
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Kantoor Taiwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Ma - Vr: 9:00 - 18:00 Taiwanese tijd (GMT+8)
+886 926 892 701+32 492 45 67 46
Kantoor Estland
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaMa - vr: 9:00 - 18:00 uur Estse tijd (EET)
+32 492 45 67 46

© 2026 Workstation AI. Alle rechten voorbehouden.

PrivacyGegevensverwijderingCookiesServicevoorwaardenWebsite-sitemap

NVIDIA, het NVIDIA-logo, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX en HGX zijn handelsmerken en/of gedeponeerde handelsmerken van NVIDIA Corporation in de VS en andere landen. AMD, het AMD Arrow-logo, EPYC, Instinct, Ryzen en Threadripper zijn handelsmerken van Advanced Micro Devices, Inc. Dell en PowerEdge zijn handelsmerken van Dell Inc. of haar dochterondernemingen. Intel en Xeon zijn handelsmerken van Intel Corporation of haar dochterondernemingen. AMAX, AceleMax en LiquidMax zijn handelsmerken van AMAX Engineering Corporation. Alle andere productnamen, logo's en merken zijn eigendom van hun respectieve eigenaren. Wij gebruiken ze uitsluitend om de producten aan te duiden die wij beschrijven, leveren of ondersteunen; het gebruik ervan betekent niet dat de eigenaren ons onderschrijven.

Home / Technische notities / Technology
AIHardwareLinuxLLMs

AI-developerlaptops: LLM's lokaal draaien onder Linux met GPU's van 16 GB en 24 GB (gids 2026)

Wat er past op een RTX 5080 of RTX 5090 Laptop GPU, de geheugenberekening, de open modellen die de moeite waard zijn, Ubuntu 26.04 inrichten met de NVIDIA-stack, Ollama, llama.cpp en vLLM, codeerassistenten, LoRA-fine-tuning, beveiliging, en wanneer werk naar een server moet

18 november 2026Technology15 min read

Een praktische gids voor engineering leads en developers die grote taalmodellen (LLM's) willen draaien op de eigen laptop van de developer, onder Linux, in plaats van op een gedeelde server of een cloud-GPU. De gids behandelt wat er past in 16 GB en 24 GB laptop-GPU-geheugen, de berekening daarachter, de open modellen die in november 2026 de moeite waard zijn, het inrichten van Ubuntu 26.04 met de NVIDIA-stack, modellen draaien met Ollama, llama.cpp en vLLM, ze koppelen aan codeertools, fine-tunen met LoRA, stroom en warmte, beveiliging, en wanneer een job naar een server of de cloud moet.

Illustratie van een 18-inch laptop die gpt-oss:20b lokaal draait, met de 16 GB van de RTX 5080 Laptop GPU, de 24 GB van de RTX 5090 Laptop GPU, tot 192 GB DDR5 en Ubuntu 26.04 LTS.

Samenvatting. GPU-geheugen bepaalt wat een laptop kan draaien. Een RTX 5080 Laptop GPU (16 GB) draait de beste open modellen van 8–20B van vandaag volledig op de GPU, waaronder gpt-oss-20b van OpenAI; een RTX 5090 Laptop GPU (24 GB) voegt de klasse van 27–32B toe, zoals Gemma 3 27B, Qwen3.8 27B, Qwen3-Coder 30B en Nemotron 3.5 Lightning van NVIDIA. Grotere modellen (Llama 3.3 70B, gpt-oss-120b) draaien door het werk te verdelen tussen de GPU en het systeemgeheugen, langzamer maar bruikbaar, en daarom doet 96–192 GB DDR5 ertoe. Reken naast het model ook op de KV-cache: bij lange context kan die even groot zijn als het model zelf. Onder Linux draait de laptop dezelfde driver, CUDA en containers als uw GPU-servers, zodat de inner loop van de ontwikkeling op het bureau blijft en alleen de zware jobs naar een server of de cloud gaan.

Deze technote hoort bij ons blogbericht AI-developerlaptops: waarom elk AI-team developers een eigen GPU zou moeten geven, dat de businesscase maakt. De voorbeeldmachine is de Juno Neptune 18", een 18-inch Linux-laptop die wij verkopen. Modelgroottes komen uit de Ollama-bibliotheek en GPU-cijfers van NVIDIA, gecontroleerd op 18 november 2026. Snelheden hangen af van het model, de kwantisatie, de context en de stroominstellingen, dus wij leggen uit hoe u meet in plaats van benchmarkcijfers te noemen.

1. Waarom de GPU op het bureau van de developer zetten

De meeste AI-ontwikkeling is een inner loop: een prompt, een retrievalstap, een tooldefinitie of een paar regels code wijzigen, draaien, de uitvoer lezen, herhalen. Die loop draait honderden keren per dag. Als elke run moet wachten op een gedeelde GPU, een cloudinstance die moet opstarten of een API met rate limits, bundelen developers hun wijzigingen en leren ze langzamer. Een lokaal model antwoordt in seconden, werkt offline en kost niets per aanroep.

  • Privacy. Broncode, klantgegevens en prompts verlaten nooit een door het bedrijf beheerd apparaat. Dat vereenvoudigt UK GDPR-beoordelingen en klantcontracten die het verzenden van data naar API's van derden verbieden.
  • Realisme. Developers zien de echte grenzen van open modellen (contextlengte, kwantisatie, geheugen) eerder dan productie.
  • Gelijkheid. Linux, de NVIDIA-driver, CUDA en containers zijn hetzelfde als op uw GPU-servers, zodat een prototype zonder wijzigingen naar een server gaat.
  • Beschikbaarheid. Geen wachtrij, geen quotum, geen afhankelijkheid van storingen tijdens de ontwikkeling.

Een laptop vervangt geen servers. Training, grote fine-tunes, lange evaluatieruns en productieserving horen op een gedeelde GPU-server of een cluster (sectie 11).

2. De machine

De cijfers die ertoe doen voor AI-werk, voor de Neptune 18" zoals geconfigureerd in onze shop. GPU-cijfers zijn van NVIDIA; de rest is van de fabrikant.

OnderdeelSpecificatieWaarom het ertoe doet
GPU (standaard)NVIDIA GeForce RTX 5080 Laptop GPU: 16 GB GDDR7, 256-bit, 7.680 CUDA-cores, 1.334 AI TOPSHoudt modellen van 8–20B en hun KV-cache op de GPU
GPU (op aanvraag)NVIDIA GeForce RTX 5090 Laptop GPU: 24 GB GDDR7, 256-bit, 10.496 CUDA-cores, 1.824 AI TOPSVoegt de klasse van 27–32B en langere context toe
GPU-vermogen150 W + 25 W Dynamic Boost in dit chassis (bereiken volgens NVIDIA: 80–150 W voor de RTX 5080, 95–150 W voor de RTX 5090 Laptop GPU)Duurzame snelheid hangt af van het vermogen; draai lange jobs met de stekker erin
CPUIntel Core Ultra 9 290HX Plus, 24 cores (8P + 16E), tot 5,5 GHz; 55 W basis, 160 W maxTokenisatie, data laden en CPU-offload van modellagen
Geheugen32 tot 192 GB DDR5 (2 modules op 5600 MHz tot 96 GB; 4 modules op 4000 MHz voor 128 en 192 GB)Ruimte voor modellen die groter zijn dan het GPU-geheugen (sectie 4)
Opslag1 × PCIe Gen 5 + 3 × PCIe Gen 4 M.2 2280, tot 16 TBModelbestanden zijn elk 5–140 GB; houd lokaal een bibliotheek aan
Scherm18" 16:10, QHD+ 240 Hz (RTX 5080) of UHD+ 200 Hz (RTX 5090), 100% DCI-P3Ruimte voor code, terminal en notebook naast elkaar
Poorten2 × Thunderbolt 4 / USB-C, 2 × USB-A, HDMI en Mini DisplayPort (verbonden met de NVIDIA-GPU), 2,5 Gb Ethernet, Wi-Fi 7Snelle overdracht van modellen en datasets
StroomAccu van 99 Wh, lader van 330 WGPU-werk doet u met de stekker erin
SoftwareKubuntu of Ubuntu 26.04 LTS voorgeïnstalleerdDezelfde OS-familie als de meeste GPU-servers

3. Wat past: GPU-geheugen beslist

Wanneer de gewichten van een model, de KV-cache en de runtime allemaal in het GPU-geheugen passen, gaat het genereren snel. Als dat niet zo is, draait een deel van het model vanuit het systeemgeheugen via PCIe en vanaf de CPU, en daalt de snelheid sterk. De eerste vraag bij elk model is dus de grootte ervan.

Staafdiagram van downloadgroottes van modellen tegenover lijnen bij 16 GB en 24 GB. Passen in 16 GB: qwen3:8b 5,2 GB, qwen3:14b 9,3 GB, gpt-oss:20b 14 GB. Hebben 24 GB nodig: gemma3:27b 17 GB, qwen3.8:27b 18 GB, qwen3-coder:30b en nemotron-3.5-lightning:30b 19 GB, qwen3:32b 20 GB. Hebben ook systeem-RAM nodig: llama3.3:70b 43 GB, gpt-oss:120b 65 GB, qwen3:235b 142 GB.

Model (Ollama-tag)DownloadRTX 5080 (16 GB)RTX 5090 (24 GB)Goed voor
qwen3:8b5,2 GBOp de GPU, lange contextOp de GPUSnelle algemene assistent, agents, RAG
qwen3:14b9,3 GBOp de GPUOp de GPUSterker redeneren met goede snelheid
gpt-oss:20b (OpenAI, MoE)14 GBOp de GPU, korte tot middellange contextOp de GPU, langere contextRedeneren, toolgebruik, algemeen programmeren
gemma3:27b (Google)17 GBDeels geoffloadOp de GPUSchrijven, meertalig, afbeeldingen als invoer
qwen3.8:27b18 GBDeels geoffloadOp de GPUProgrammeren, onderzoek en agenttaken, tekst en afbeeldingen
qwen3-coder:30b (MoE, ongeveer 3B actief)19 GBExperts geoffload, nog bruikbaarOp de GPUCodeaanvulling en codeeragents
nemotron-3.5-lightning:30b (NVIDIA, MoE, 3B actief)19–25 GBExperts geoffloadKleinere kwantisatie op de GPUAltijd actieve agents, tot 1M context
qwen3:32b20 GBDeels geoffloadOp de GPU, korte contextDichte 32B-kwaliteit
llama3.3:70b (Meta)43 GBGPU + systeem-RAM (64 GB of meer): traag, prima voor controlesVergelijken met een model van serverklasse
gpt-oss:120b (OpenAI, MoE, 5,1B actief)65 GBGPU + systeem-RAM (96 GB of meer): bruikbaar dankzij MoEBijna-frontier open redeneren op een laptop
qwen3:235b (MoE)142 GBGPU + 192 GB RAM: experimenteelEen zeer groot model uitproberen voordat u een server koopt

De groottes zijn de standaard Ollama-tags, meestal 4-bitkwantisaties. Licenties verschillen (Apache 2.0, de Gemma-voorwaarden, de Llama-licentie van Meta, de open-modellicentie van NVIDIA en andere): controleer elke modelkaart voordat u een model commercieel gebruikt.

4. De geheugenberekening

Drie dingen delen het GPU-geheugen: de gewichten, de KV-cache en de runtime.

Gewichten

weights ≈ parameters × bits per weight ÷ 8. Een 14B-model is 28 GB in 16-bit, ongeveer 14–15 GB in 8-bit en ongeveer 8–9 GB in 4-bit (4-bitformaten slaan per blok iets extra op, dus echte bestanden zijn iets groter dan een halve byte per parameter). Het kwaliteitsverlies bij een goede 4-bitkwantisatie is voor het meeste ontwikkelwerk klein; 8-bit ligt dicht bij het origineel. Blackwell-GPU's, waaronder de RTX 50-serie, ondersteunen FP4 en FP8 ook in hardware, wat runtimes zoals TensorRT-LLM en vLLM kunnen benutten.

KV-cache

Voor elk token in de context slaat elke laag een key en een value op: KV bytes per token = 2 × layers × KV heads × head size × bytes per value. Voor Llama 3.1 8B is dat 2 × 32 × 8 × 128 × 2 = 131.072 bytes (128 KiB) in 16-bit. Het groeit lineair met de contextlengte en met het aantal verzoeken dat tegelijk wordt bediend.

Gestapelde staven voor Llama 3.1 8B in 4-bit: bij 8K tokens maken 4,9 GB gewichten, 1,1 GB KV-cache en 1 GB runtime samen 7,0 GB. Bij 32K maakt 4,3 GB cache samen 10,2 GB. Bij 128K maakt 17,2 GB cache samen 23,1 GB, boven 16 GB en net onder 24 GB.

Een 8B-model dat 5 GB op schijf is, heeft dus ongeveer 23 GB nodig bij zijn volledige context van 128K. Drie manieren om het te laten passen:

  • Gebruik de context die u nodig hebt. Het meeste programmeer- en RAG-werk gaat prima met 16–32K. Runtimes reserveren de cache voor de context die u instelt, dus stel die in.
  • Kwantiseer de cache. Een 8-bit-KV-cache halveert die met weinig kwaliteitsverlies; 4-bit brengt hem terug tot een kwart. Stel in Ollama OLLAMA_FLASH_ATTENTION=1 en OLLAMA_KV_CACHE_TYPE=q8_0 in; gebruik in llama.cpp --cache-type-k q8_0 --cache-type-v q8_0.
  • Geef de voorkeur aan modellen met grouped-query- of andere compacte attention. Minder KV-heads betekent een kleinere cache; de modelkaart vermeldt ze.

Runtime

Reken op 1–2 GB voor de CUDA-context, activaties en buffers, en onthoud dat ook de desktop wat GPU-geheugen gebruikt wanneer schermen via de NVIDIA-GPU lopen. Controleer met nvidia-smi voordat u een model laadt.

Snelheid, en waarom systeemgeheugen nog steeds belangrijk is

Voor elk gegenereerd token wordt elk actief gewicht één keer gelezen, dus de generatiesnelheid wordt vooral begrensd door de geheugenbandbreedte: GDDR7 op de GPU is meerdere keren sneller dan het DDR5 in de laptop. Daarom vertraagt een model dat naar het systeemgeheugen overloopt, en daarom zijn mixture-of-experts-modellen (MoE) de uitzondering: gpt-oss-120b heeft 117B parameters, maar slechts ongeveer 5,1B zijn per token actief, dus de gedeelde lagen op de GPU houden en de experts in het systeemgeheugen geeft nog steeds bruikbare snelheid. Voor dat soort werk helpt meer en sneller systeemgeheugen: twee modules op 5600 MHz zijn sneller dan vier op 4000 MHz, dus kies 96 GB (2 × 48 GB), tenzij u 128 of 192 GB nodig hebt voor de capaciteit.

Meet op uw eigen werk: ollama run <model> --verbose drukt de snelheden van promptverwerking en generatie af in tokens per seconde, en llama-bench doet hetzelfde voor llama.cpp.

5. Ubuntu 26.04 inrichten voor AI-werk

De Linux-AI-stack in zeven lagen: uw werk; modelruntimes zoals Ollama, llama.cpp, LM Studio, vLLM, SGLang en TensorRT-LLM; frameworks zoals PyTorch, Transformers, PEFT en Unsloth; Docker of Podman met de NVIDIA Container Toolkit; de NVIDIA-driver, CUDA, cuDNN en NCCL; Ubuntu 26.04 LTS; en de hardware.

Machines van ons worden geleverd met de NVIDIA-driver geïnstalleerd en gecontroleerd. Om er een te controleren of opnieuw op te bouwen:

# Is the NVIDIA GPU visible, and which driver is in use?
nvidia-smi

# Ubuntu's recommended NVIDIA driver (signed for Secure Boot)
sudo ubuntu-drivers list
sudo ubuntu-drivers install
sudo reboot

# Laptops with two GPUs: run everything on the NVIDIA GPU, or only what asks for it
prime-select query
sudo prime-select nvidia       # or: on-demand

Met Secure Boot aan moet bij een lokaal gebouwde driver de ondertekeningssleutel bij de volgende start worden ingeschreven (MOK); de verpakte drivers van Ubuntu vermijden die stap. Haal de driver uit het archief van Ubuntu of uit de repository van NVIDIA, niet uit beide.

Containers met de GPU

Containers houden CUDA-versies per project gescheiden en komen overeen met wat op servers draait. Installeer Docker (of Podman), daarna de NVIDIA Container Toolkit uit de apt-repository van NVIDIA volgens de installatiehandleiding van NVIDIA, en koppel hem:

sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# Test: the container should list the laptop GPU
docker run --rm --gpus all ubuntu nvidia-smi

Python

Gebruik één virtuele omgeving per project (uv of venv) en installeer PyTorch met de CUDA-build die de installatiepagina voor uw driver aanbeveelt. Controleer het met python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))".

6. Modellen draaien

Ollama: de snelste start

curl -fsSL https://ollama.com/install.sh | sh
ollama run gpt-oss:20b            # downloads once, then runs locally
ollama ps                         # shows how much of the model is on the GPU vs the CPU

ollama ps is de eerste controle: "100% GPU" is wat u wilt zien. Als er een CPU-aandeel staat, verklein dan de context, kwantiseer de KV-cache of kies een kleiner model. Ollama luistert op 127.0.0.1:11434 en biedt een OpenAI-compatibele API op /v1, dus de meeste tools kunnen het ongewijzigd gebruiken.

llama.cpp: volledige controle

# All layers on the GPU, 32K context, 8-bit KV cache, OpenAI-compatible server on :8080
llama-server -m qwen3-14b-q4_k_m.gguf --n-gpu-layers 99 --ctx-size 32768 \
  --cache-type-k q8_0 --cache-type-v q8_0 --host 127.0.0.1 --port 8080

# A MoE model bigger than GPU memory: keep shared layers on the GPU, put experts in system RAM
# (recent llama.cpp builds; raise the number until it fits)
llama-server -m gpt-oss-120b.gguf --n-gpu-layers 99 --n-cpu-moe 24 --ctx-size 16384

vLLM: het dichtst bij productieserving

pip install vllm
vllm serve Qwen/Qwen3-8B --max-model-len 16384 --gpu-memory-utilization 0.85
# OpenAI-compatible API on http://127.0.0.1:8000/v1

vLLM reserveert vooraf GPU-geheugen voor de KV-cache, dus houd modellen op een laptop-GPU van 16 GB klein en stel --max-model-len in. De waarde zit in de gelijkheid: dezelfde server, vlaggen en API als op uw GPU-servers.

LM Studio is een desktopapp voor hetzelfde werk, met een modelbrowser en een lokale API, handig voor mensen die niet in een terminal leven.

7. Codeerassistenten en agents op een lokaal model

De meeste IDE-assistenten, codeeragents en agentframeworks accepteren een OpenAI-compatibele base-URL. Laat ze wijzen naar http://127.0.0.1:11434/v1 (Ollama), :8080/v1 (llama.cpp) of :8000/v1 (vLLM). Praktische keuzes in november 2026:

  • Aanvulling tijdens het typen: een klein, snel model (qwen3:8b of vergelijkbaar). Latentie telt meer dan grootte.
  • Chat en refactoring: gpt-oss:20b op 16 GB; qwen3-coder:30b of qwen3.8:27b op 24 GB.
  • Agents met tools: modellen die zijn getraind voor tool calling (gpt-oss, de Qwen3-familie, Nemotron 3.5 Lightning), met genoeg context voor de toolresultaten, doorgaans 32K of meer.

Houd een gehost frontier-model aan voor de moeilijkste problemen als uw beleid dat toestaat; het lokale model verwerkt het dagelijkse volume privé. Veel teams routeren per taak: standaard lokaal, gehost op verzoek.

8. Fine-tunen op een laptop

Volledige fine-tuning van zelfs een 7B-model vereist veel meer dan 24 GB. LoRA en QLoRA trainen kleine adaptermatrices bovenop bevroren gewichten (QLoRA houdt het basismodel in 4-bit), waardoor fine-tuning op een laptop mogelijk wordt:

  • 16 GB (RTX 5080): QLoRA op 7–8B-modellen bij bescheiden sequentielengtes; tot ongeveer 14B met geheugenbesparende tooling en korte sequenties.
  • 24 GB (RTX 5090): QLoRA op 14B zonder problemen, en tot ongeveer 30B met korte sequenties.
  • Daarboven: fine-tunes van 70B en volledige fine-tunes gaan naar een server (sectie 11).

Gebruik Hugging Face PEFT en TRL, of Unsloth voor een lager geheugengebruik, met gradient checkpointing en een batchgrootte van één of twee plus gradient accumulation. Deze bereiken hangen af van sequentielengte, rank en tooling: begin klein, houd nvidia-smi in de gaten en groei. De laptop is ideaal om dataformaten, hyperparameters en evaluatiescripts op een kleine run te controleren voordat u voor een lange betaalt.

9. Stroom, warmte en accu

  • Sluit de stroom aan voor GPU-werk. Op de accu draait de GPU met verminderd vermogen; de lader van 330 W houdt GPU-belastingen van 150 W+ vol.
  • Houd het in de gaten: nvidia-smi dmon -s pucm streamt vermogen, bezetting, kloksnelheden en geheugen; nvidia-smi -q -d POWER,TEMPERATURE toont de limieten.
  • Lange jobs: houd de ventilatieopeningen vrij, gebruik het prestatieprofiel en reken op ventilatorgeluid. Voor jobs van meerdere uren is een desktop of server het betere gereedschap.

10. Beveiliging en governance

  • Versleutel de schijf. Volledige schijfversleuteling (LUKS) beschermt code, data en modelbestanden als de laptop verloren raakt; wij richten die vóór verzending in als dat is besteld.
  • Houd modelservers lokaal. Ollama, llama.cpp en vLLM hebben standaard geen gebruikersauthenticatie. Bind ze aan 127.0.0.1; stel ze nooit beschikbaar op 0.0.0.0 op kantoor- of openbare wifi zonder een proxy die authenticeert.
  • Weet waar modellen vandaan komen. Download uit de officiële repositories van de uitgever, geef de voorkeur aan safetensors en GGUF boven formaten die bij het laden code kunnen uitvoeren, en houd een lijst bij van goedgekeurde modellen en hun licenties.
  • Beheer het apparaat. Updates, schijfversleuteling en schermvergrendeling vallen onder uw normale apparaatbeheer; lokaal verwerkte data blijft persoonsgegevens onder de UK GDPR.

11. Wanneer werk van de laptop af moet

Drie kolommen: op de laptop de dagelijkse inner loop van prompts, codeerassistenten, RAG-prototypes, tests, kleine LoRA-fine-tunes en offline werk; op een gedeelde GPU-server wekelijkse teamevaluaties, fine-tunes van 30 tot 70B, een teamendpoint, jobs met lange context en modellen boven 24 GB; op een cluster of in de cloud piekwerk zoals pre-training, productieserving, loadtests en jobs over meerdere nodes.

SignaalVerplaatsen naar
Het model heeft op volle snelheid meer dan 24 GB nodig, of lange context voor veel gebruikersEen workstation of server met RTX PRO 6000 (96 GB) of een DGX-systeem
Een job draait urenlang, of blokkeert de machine van de developerEen gedeelde GPU-server, ingepland
Meerdere developers hebben de hele dag hetzelfde model nodigEén inferentie-endpoint voor het team in plaats van veel kopieën
Training over meerdere GPU's of productieservingCluster of cloud, met dataresidentie in het Verenigd Koninkrijk waar nodig

Nog niet klaar om te kopen? Workstation Rentals verhuurt AI-laptops en GPU-workstations per week of per maand, en GPU Leasing legt uit hoe leasen werkt.

12. Welke configuratie voor welke developer

RolGPUSysteemgeheugenOpslag
Applicatiedeveloper die AI gebruikt (RAG, agents, assistenten)RTX 5080, 16 GB64 GB2 TB
AI-engineer (evaluatie, fine-tuning, modellen van 27–32B)RTX 5090, 24 GB96 GB (2 × 48 GB, snelst)4 TB
Onderzoeker die zeer grote MoE-modellen lokaal uitprobeertRTX 5090, 24 GB128–192 GB4 TB of meer
Data scientist (notebooks, klassieke ML, kleine modellen)RTX 5080, 16 GB64–96 GB2–4 TB

13. Veelgestelde vragen

Kan een laptop echt een model van 120B draaien? gpt-oss-120b wel, met 96 GB of meer systeemgeheugen, omdat per token maar ongeveer 5,1B parameters actief zijn. Dichte 70B-modellen draaien ook, maar langzaam; gebruik ze om antwoorden te vergelijken, niet voor interactief werk.

16 GB of 24 GB? 16 GB dekt de klasse van 8–20B, die het meeste ontwikkelwerk aankan. Kies 24 GB als u werkt met modellen van 27–32B, lange contexten of fine-tuning boven 8B.

Waarom Linux en niet Windows? Servers, containers en de meeste AI-tooling zijn Linux-first. Ontwikkelen op hetzelfde OS neemt een hele klasse "werkt op mijn machine"-problemen weg.

Vervangt een lokaal model gehoste frontier-modellen? Niet voor de moeilijkste taken. Het neemt het dagelijkse volume privé en goedkoop voor zijn rekening; houd een gehost model aan voor wat dat nodig heeft, waar het beleid dat toestaat.

En Apple silicon? Macs met veel unified memory draaien grote modellen goed met MLX, maar zonder CUDA. Als uw servers NVIDIA en Linux zijn, houdt een NVIDIA-Linux-laptop de stack identiek.

Bronnen

  • NVIDIA, specificaties van de GeForce RTX 50-serie voor laptops (CUDA-cores, AI TOPS, geheugen, interfacebreedte, GPU-vermogensbereik), gecontroleerd op 18 november 2026.
  • Pagina's in de Ollama-bibliotheek voor qwen3, gpt-oss, gemma3, qwen3.8, qwen3-coder, nemotron-3.5-lightning en llama3.3 (downloadgroottes en beschrijvingen), gecontroleerd op 18 november 2026.
  • OpenAI, modelkaart van gpt-oss (117B parameters in totaal en ongeveer 5,1B actief voor gpt-oss-120b).
  • Meta, configuratie van Llama 3.1 8B (32 lagen, 8 KV-heads, headgrootte 128), gebruikt voor het voorbeeld van de KV-cache.
  • Juno Computers, specificaties van de Neptune 18"; vermelding in de Workstation-shop (configuratie, prijs en verzendtijd).
  • De commando's volgen de documentatie van Ubuntu, de NVIDIA Container Toolkit, Ollama, llama.cpp en vLLM; vlaggen veranderen tussen releases, dus controleer de actuele documentatie.

Erkenning van rechten: NVIDIA, GeForce, RTX, CUDA, cuDNN, NCCL, TensorRT, DGX, Blackwell en Nemotron zijn handelsmerken van NVIDIA Corporation. Intel en Core Ultra zijn handelsmerken van Intel Corporation. Ubuntu en Kubuntu zijn handelsmerken van Canonical Ltd. Juno en Neptune zijn namen van Juno Computers Ltd. Llama is een handelsmerk van Meta Platforms, Inc.; Gemma van Google LLC; Qwen van Alibaba Cloud; gpt-oss en OpenAI van OpenAI. Andere namen zijn eigendom van hun respectieve eigenaren. Dit artikel is onafhankelijk en wordt door geen van deze bedrijven onderschreven.

Deel dit artikel

Meer in Technology

ML- en LLM-systemen testen die u niet correct kunt bewijzen: een Python-kit voor bewijsmateriaal

ML- en LLM-systemen testen die u niet correct kunt bewijzen: een Python-kit voor bewijsmateriaal

Bewijsmateriaal in plaats van bewijzen, in ongeveer 400 regels Python met echte output: slice-metrics met bootstrap-intervallen en een pass/fail-contract, property- en metamorfe tests met Hypothesis, kalibratie en conformal prediction, Pydantic-contracten en regressie-evals voor LLM-output, driftcontroles, een CI-gate en exacte verificatie van een klein neuraal netwerk

Lees meer
TorchCurves in de praktijk: leerbare B-spline- en Legendre-curves in PyTorch

TorchCurves in de praktijk: leerbare B-spline- en Legendre-curves in PyTorch

torchcurves installeren, een curve fitten en dimensioneren, kiezen tussen B-spline en Legendre en de input map, een monotone kalibratiecurve en een additief model op tabeldata bouwen, vergelijken met SciPy, scikit-learn, een KAN en een MLP, coëfficiënten naar JSON exporteren, testen en in productie draaien, met echte output

Lees meer
Agentic, spraak- en visionmodellen on-device draaien met Cactus: een praktische gids (2026)

Agentic, spraak- en visionmodellen on-device draaien met Cactus: een praktische gids (2026)

Installeer cactus-compute, doe toolcalls, gate op confidence met een terugval naar een groter model, extraheer gestructureerde data, draai spraak en vision, meet latentie en geheugen en lever een offline container uit, met elk voorbeeld uitgevoerd en een vergelijking met llama.cpp, ONNX Runtime, ExecuTorch, MLC LLM en TensorRT Edge-LLM

Lees meer