---
title: ""
canonical: "https://studiomeyer.academy/en/playbooks/welches-lokale-modell-passt-zu-deiner-hardware"
language: en
publisher: "StudioMeyer Academy, https://studiomeyer.academy (llms.txt: https://studiomeyer.academy/llms.txt)"
---

[← Alle Playbooks](https://studiomeyer.academy/playbooks)

Playbook· lokal

# Which local model fits your hardware

From eight gigabytes to a server with two graphics cards. How to get from your actual kit to the right model size in ten steps, instead of guessing and then learning from the crash.

The most common disappointment with local AI is not that it does not work. It is that somebody pulls the largest model they saw recommended somewhere, and the machine then either crashes or produces one word per second. After that the verdict is "local is useless", when all that was wrong was the size.

This playbook turns the order around. Look at your hardware first, derive the size class from it, and only then choose within that class by task. At the end you have two candidates and a method for comparing them on your own work.

## 1\. Work out how much memory is actually available

What counts is not the memory in the machine, but the memory the model actually gets.

On a Mac with Apple Silicon, processor and graphics share the same memory, and only part of it goes to the model. As a rough guide reckon with two thirds to three quarters: 32 GB gives you around 22 GB usable, 64 GB about 45. The exact share is set by your runtime and has changed between versions, so treat the figure as a guide rather than a promise.

With a dedicated graphics card only its own memory counts, regardless of how much RAM sits in the machine. It is not entirely yours there either, though: display output and drivers take half a gigabyte to a full one. So a 12 GB card leaves you roughly 11 GB. If the model does not fit, part of it is offloaded to the main processor, and then speed collapses.

**Tip:** If you only keep one number, keep this one: usable memory, not installed memory.

## 2\. Estimate a model's size in your head

A rule of thumb for a rough estimate, without hunting for a table. At the usual Q4 compression a model needs roughly half as many gigabytes as it has billions of parameters. An 8B model lands around 4 to 5 GB, a 32B model around 18 to 20 GB. That estimates the weights, not the whole requirement, and the exact download size is stated on every model anyway. Use the formula to shortlist and the real number to decide.

On top of that comes room for context, meaning what you type in and what the model holds on to. For short conversations about one extra gigabyte is enough, for long documents considerably more.

**Tip:** Always plan two to three gigabytes of headroom. A model that fits exactly has no room left for your text and gets slow on the first longer document.

## 3\. Place yourself in one of four classes

As of August 2026, at the usual Q4 compression:

The figures below are **usable** memory, so a graphics card's VRAM or the Apple Silicon share from step 1, not the number on the box.

With **8 GB usable** a model in the 7 to 9 billion class runs. It works, but with no reserve for long texts. Fine for summaries and short tasks.

With **16 GB usable** it gets comfortable. The same class runs smoothly with decent context, or you move up to 14 billion.

With **24 to 32 GB usable** you reach the 32 billion class. This is where local starts being serious on substance.

From **44 GB usable** models in the 70 billion class become possible, which at Q4 occupy roughly 38 to 42 GB depending on the model. On Apple Silicon that makes 64 GB installed the absolute floor, and a tight one: at a two-thirds usable share that is around 43 GB, so barely the model and hardly any context. That class only gets comfortable there with more. It is the class where you stop noticing the gap to the cloud on every answer.

**Tip:** These thresholds move, and they move in your favour, because models keep getting more efficient. A 30B model today beats a 70B model from eighteen months ago.

## 4\. Choose within your class by task

Inside a size class there are families with different strengths. The landscape changes fast, so here is the pattern rather than a ranking that will be wrong in three months.

For general text work and multilingual use, Alibaba's Qwen family is the solid 2026 default, partly because many of its models ship under Apache 2.0 and come in many sizes. The licence applies per model and per revision, though, not to a family as a whole, so the look at the model card is still due. For programming there are dedicated coder variants inside the families that are clearly better than the general model at the same size. For small devices and tight memory, Google's Gemma line is built for frugality. If you want models that expose their reasoning, look at the reasoning variants, for example OpenAI's gpt-oss line.

**Tip:** Never take a general model for code when a coder variant of the same family exists. At identical memory footprint that difference is bigger than the one between two families.

## 5\. Check the licence before it turns commercial

Open weights does not automatically mean free use. Apache 2.0 and MIT are uncomplicated, you may work commercially with those. Other licences carry restrictions, on user numbers or attribution for instance.

Licence terms apply privately too, they just surface less often. The moment a client is involved or the model sits inside a product, the formality turns into a risk.

**Tip:** The licence is on the model card at Hugging Face. One look, thirty seconds, saves an awkward question in a sales meeting.

## 6\. Download two candidates, not one

The mistake is deciding beforehand. Pull two models from your class that come from different families. The disk space costs you nothing permanent, and comparing on your own work is worth more than any leaderboard.

**Tip:** Do not take two sizes from the same family. The bigger one wins predictably. Take two different families at the same size, that is the question you actually have.

## 7\. Build yourself ten real test cases

Collect ten tasks from your daily work where you can judge whether the result is good. Rewrite an email, summarize minutes, interpret a table, whatever you actually do.

Put them in a file and send each to both models. Do not judge while reading. Collect all twenty answers first, then go through them.

**Tip:** Include tasks that the cloud models struggle with. That is exactly where it becomes clear whether local is enough for you.

## 8\. Measure speed, but the right one

Two numbers matter differently. Time to the first word you notice immediately in conversation. Words per second after that you only notice when they drop below your reading speed.

A model that starts after one second and then writes steadily feels better than one that thinks for three seconds and then types faster. For bulk processing in the background it is exactly the other way round, there only throughput counts.

**Tip:** My personal threshold sits around ten words per second, roughly reading speed. Below that the work feels sluggish. That is a rule of thumb rather than a measured standard; runtimes report tokens rather than words anyway, and German needs more tokens per word than English. If it feels sluggish, go down a class, the overall result gets better.

## 9\. Decide, and write down the reason

Pick the model that convinced you more often across your ten test cases. Not the one with the better benchmark scores, not the one recommended in a forum.

Note in two sentences why. You will need that note in three months when the next generation lands and you compare again. Then you have both the test cases and the yardstick ready.

**Tip:** Keep the ten test cases. They are your personal benchmark and worth more than any public leaderboard, because they measure your work and not somebody else's.

## 10\. Plan the switch from the start

The model you pick today will not be the best one in six months. That is fine, as long as you have not hard-wired it.

Keep the model name in one place in your configuration, not scattered across ten scripts. Then switching is a single line. Whoever writes the name everywhere stops switching out of inconvenience and ends up two generations behind.

**Tip:** The same principle applies to cloud models. How to catch model releases at all instead of discovering them by accident is in [Track model availability](https://studiomeyer.academy/playbooks/modell-verfuegbarkeit-tracken).

## What next

If you have no model running yet, start with [Your first local AI model in 30 minutes](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten). If the hardware question is settled and it is now about company use, [Local AI and the GDPR](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) covers the legal part. And if you want to know whether your own machine pays off against the cloud at all, the arithmetic is in [Local or cloud, the honest arithmetic](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung).

## Sources

Memory figures are approximations at Q4 compression, as of August 2026, and vary with model architecture and context length. Check the concrete value on the model card.

- Ollama, model library with size figures: https://ollama.com/library
- Hugging Face, model cards with licence and weights: https://huggingface.co/models
- llama.cpp, documentation on quantization levels: https://github.com/ggml-org/llama.cpp

[← Your first local AI model in 3](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten) [Local AI and the GDPR, what it →](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo)

Alle Playbooks

[01. From ChatGPT to Claude, guide in 10 steps](https://studiomeyer.academy/playbooks/von-chatgpt-zu-claude) [02. From ChatGPT to Codex, guide in 10 steps](https://studiomeyer.academy/playbooks/von-chatgpt-zu-codex) [03. Your first MCP server in 90 minutes](https://studiomeyer.academy/playbooks/erster-mcp-server-in-90-minuten) [04. Using memory portably, same memory in Claude, Codex and Cursor](https://studiomeyer.academy/playbooks/memory-portabel-nutzen) [05. DACH legal. EU AI Act and GDPR for AI operators](https://studiomeyer.academy/playbooks/dach-legal-eu-ai-act-und-dsgvo) [06. Your first sub-agent in 30 minutes](https://studiomeyer.academy/playbooks/erster-sub-agent-in-30-min) [07. Publishing an MCP server step by step](https://studiomeyer.academy/playbooks/mcp-server-publishen) [08. Hooks against hallucinations](https://studiomeyer.academy/playbooks/hooks-gegen-halluzinationen) [09. Git for AI, 30-minute quickstart](https://studiomeyer.academy/playbooks/git-fuer-ki-quickstart) [10. Scheduled agents with Claude Code routines](https://studiomeyer.academy/playbooks/scheduled-agents-mit-routines) [11. Avoiding tool sprawl, from 530 to 30 MCP tools per session](https://studiomeyer.academy/playbooks/tool-sprawl-vermeiden) [12. Claude Code update strategy, without your workflow suddenly breaking](https://studiomeyer.academy/playbooks/claude-code-update-strategie) [12. Structuring your subagent team, the six roles you need in a daily driver](https://studiomeyer.academy/playbooks/subagent-team-strukturieren) [13. Claude Code cost controls for daily drivers, staying under 30 dollars a day in 10 steps](https://studiomeyer.academy/playbooks/claude-code-cost-controls-fuer-daily-driver) [14. Your own slash commands for Claude Code, productive in 30 minutes](https://studiomeyer.academy/playbooks/eigene-slash-commands-fuer-claude-code) [15. Claude Code headless in CI/CD, a setup that runs tomorrow](https://studiomeyer.academy/playbooks/claude-code-headless-in-ci-cd) [16. Agent eval in 60 minutes, how to find out if your agent is any good](https://studiomeyer.academy/playbooks/agent-eval-in-60-minuten) [17. Plan Mode in Claude Code, the invisible seatbelt, when you need it and how to keep it on](https://studiomeyer.academy/playbooks/plan-mode-richtig-nutzen) [18. Debugging MCP when nothing works, the 10 checks that solve 90 percent of cases](https://studiomeyer.academy/playbooks/mcp-debuggen-wenn-nichts-geht) [18. Mastering prompt caching, from cache miss to an 80 percent hit rate in 10 steps](https://studiomeyer.academy/playbooks/prompt-caching-meistern) [19. Repair memory drift, when your agent's memory starts contradicting itself](https://studiomeyer.academy/playbooks/memory-drift-reparieren) [20. MCP STDIO security, what the OX Security story means for you](https://studiomeyer.academy/playbooks/mcp-stdio-sicherheit) [21. Opus 4.7 migration, what changed for API builders](https://studiomeyer.academy/playbooks/opus-4-7-migration) [22. Your first Skill in 30 minutes, when slash commands aren't enough](https://studiomeyer.academy/playbooks/erste-eigene-skill-in-30-min) [23. Managing the context window in long Claude Code sessions](https://studiomeyer.academy/playbooks/context-window-managen-claude-code) [24. Advisor Tool, Opus as advisor and Sonnet as executor in one API call](https://studiomeyer.academy/playbooks/advisor-tool-opus-als-berater-sonnet-als-executor) [25. Secure your MCP server with OAuth 2.1 in 60 minutes](https://studiomeyer.academy/playbooks/mcp-server-auth-mit-oauth-2-1) [26. Distributing plugin bundles via URL, --plugin-url in 30 minutes](https://studiomeyer.academy/playbooks/plugin-bundle-via-url-distribution) [27. Claude Code in a Team, how to keep CLAUDE.md alive without turning it into a trash bin](https://studiomeyer.academy/playbooks/claude-code-im-team-claude-md-gemeinsam-pflegen) [27. Loading third-party Claude Code plugins from ZIP and URL, safely in 20 minutes](https://studiomeyer.academy/playbooks/claude-code-plugins-aus-zip-und-url-laden) [28. Confused deputy audit for Claude Code, done in 25 minutes](https://studiomeyer.academy/playbooks/confused-deputy-audit-fuer-claude-code) [28. Your first Claude Code plugin in 60 minutes, from empty folder to installable bundle](https://studiomeyer.academy/playbooks/dein-erstes-claude-code-plugin) [29. Pull request reviews with Claude Code, 10 steps for a PR workflow nobody blocks anymore](https://studiomeyer.academy/playbooks/pull-request-reviews-mit-claude-code) [30. Claude Projects for non-coders, a productive workspace in 30 minutes](https://studiomeyer.academy/playbooks/claude-projects-fuer-nicht-coder) [31. Build a prompt library, reuse your favourite prompts without copy-paste](https://studiomeyer.academy/playbooks/prompt-bibliothek-aufbauen) [32. Output Styles for Claude Code, your own tone in 20 minutes](https://studiomeyer.academy/playbooks/output-styles-fuer-claude-code) [33. Statusline for Claude Code, context at a glance in 15 minutes](https://studiomeyer.academy/playbooks/statusline-fuer-claude-code) [34. Claude Code checkpoints and /rewind: your safety net for risky edits](https://studiomeyer.academy/playbooks/claude-code-checkpoints-und-rewind) [34. Keeping discovery files consistent so AI crawlers do not quote old nonsense bios](https://studiomeyer.academy/playbooks/discovery-files-konsistent-halten) [34. Debugging hooks when nothing fires](https://studiomeyer.academy/playbooks/hooks-debuggen-wenn-nichts-feuert) [34. Parallel Claude Code sessions with git worktrees, two branches at once without conflict](https://studiomeyer.academy/playbooks/parallele-claude-sessions-mit-worktrees) [34. Skill does not trigger, what to check in 10 steps before you type /command again](https://studiomeyer.academy/playbooks/skill-trigger-debugging) [34. Sub-agent or skill or MCP tool, which one do you pick when](https://studiomeyer.academy/playbooks/sub-agent-oder-skill-oder-mcp-tool) [35. Running parallel Claude Code sessions with git worktrees](https://studiomeyer.academy/playbooks/claude-code-mit-git-worktrees) [35. Memory backup before an update, so you do not cry over a schema migration bug](https://studiomeyer.academy/playbooks/memory-backup-vor-update) [36. AGENTS.md alongside CLAUDE.md, one repo context for several AI tools](https://studiomeyer.academy/playbooks/agents-md-neben-claude-md) [47. Generative Engine Optimization for small sites, so Perplexity and ChatGPT-Search cite you](https://studiomeyer.academy/playbooks/geo-fuer-kleine-sites) [50. Opus 4.8 migration, the first Opus update with no breaking changes](https://studiomeyer.academy/playbooks/opus-4-8-migration) [51. Background sessions with Claude agents: run long tasks without blocking your terminal](https://studiomeyer.academy/playbooks/background-sessions-mit-claude-agents) [52. Set up the Claude Code bash sandbox: isolate commands instead of blindly allowing them](https://studiomeyer.academy/playbooks/claude-code-bash-sandbox-einrichten) [53. From script to your own agent: the Claude Agent SDK in 90 minutes](https://studiomeyer.academy/playbooks/claude-agent-sdk-erster-eigener-agent) [54. Build an MCP App: interactive UI in your MCP tool instead of a wall of text](https://studiomeyer.academy/playbooks/mcp-app-interaktive-ui-bauen) [55. The expensive-model myth: when the top AI model is really worth it](https://studiomeyer.academy/playbooks/mythos-klasse-wann-lohnt-sich-das) [56. Setting up fallback models so Claude Code doesn't stall on overload](https://studiomeyer.academy/playbooks/claude-code-fallback-modelle) [57. Dynamic workflows in Claude Code, your first orchestrated multi-agent script](https://studiomeyer.academy/playbooks/dynamic-workflows-in-claude-code) [58. Security-guidance plugin for Claude Code, automatic security review while you build](https://studiomeyer.academy/playbooks/claude-code-security-guidance-plugin) [59. Claude Code acting up after a config change, how to find the cause](https://studiomeyer.academy/playbooks/claude-code-safe-mode-diagnose) [60. MCP is stateless: what the 2026-07-28 spec changes and what you need to do now](https://studiomeyer.academy/playbooks/mcp-spec-2026-07-was-aendert-sich) [61. Your first real n8n flow: automation for people who don't code](https://studiomeyer.academy/playbooks/mein-erster-n8n-flow-fuer-nicht-coder) [62. Agentic payments with x402, what builders need to know about machine-paid APIs](https://studiomeyer.academy/playbooks/agentic-payments-x402) [63. GPT-5.6 or Opus 5, which model for which task](https://studiomeyer.academy/playbooks/gpt-5-oder-opus-4-8-welches-modell) [64. Subagents that spawn subagents, Claude Code's 5-level rule](https://studiomeyer.academy/playbooks/subagents-die-subagents-spawnen) [65. Setting up Claude Code agent teams, multiple sessions working together](https://studiomeyer.academy/playbooks/claude-code-agent-teams-einrichten) [66. Tracking model availability, when a model vanishes overnight](https://studiomeyer.academy/playbooks/modell-verfuegbarkeit-tracken) [67. Data protection when working with AI tools: ten habits that keep you safe](https://studiomeyer.academy/playbooks/datenschutz-mit-ki-tools) [68. Using Auto Mode in Claude Code safely, in 10 steps without suicide commands](https://studiomeyer.academy/playbooks/claude-code-auto-mode-sicher-nutzen) [69. AI for the job hunt: 10 steps through the ATS filter](https://studiomeyer.academy/playbooks/ki-fuer-jobsuche) [70. Build an AI portfolio that lands you a job, in 10 steps](https://studiomeyer.academy/playbooks/ai-portfolio-fuer-den-job) [71. Proving your AI skills credibly in CV and interview](https://studiomeyer.academy/playbooks/ai-skills-belegen-lebenslauf-interview) [72. Effort levels in Claude Code, when low is enough and when you need max](https://studiomeyer.academy/playbooks/effort-level-in-claude-code-einstellen) [73. From Academy skill to your first paid AI gig](https://studiomeyer.academy/playbooks/erster-bezahlter-ki-auftrag) [74. Fact-checking an AI answer: 10 steps against wrong information](https://studiomeyer.academy/playbooks/ki-antwort-faktenchecken) [75. AI images for your brand, from first prompt to finished set](https://studiomeyer.academy/playbooks/ki-bilder-fuer-deine-marke) [76. AI for freelancers, writing quotes and client emails in half the time](https://studiomeyer.academy/playbooks/ki-fuer-selbststaendige-angebote-und-mails) [77. Spotting and correctly labelling AI content](https://studiomeyer.academy/playbooks/ki-inhalte-erkennen-und-kennzeichnen) [78. AI meeting notes that are actually usable](https://studiomeyer.academy/playbooks/ki-notizen-fuer-meetings) [79. Local AI on your own machine, so your data never leaves the house](https://studiomeyer.academy/playbooks/lokale-ki-auf-dem-eigenen-rechner) [80. Understanding the three MCP primitives. Tools, Resources and Prompts](https://studiomeyer.academy/playbooks/mcp-primitives-tools-resources-prompts) [81. Reliable JSON from any AI, so your automation doesn't break](https://studiomeyer.academy/playbooks/verlaessliches-json-aus-ai) [82. What AI tools really cost, and where the hidden bills hide](https://studiomeyer.academy/playbooks/was-kostet-ki-wirklich) [83. Understanding prompt injection, the three traps when your AI assistant reads foreign text](https://studiomeyer.academy/playbooks/prompt-injection-erkennen) [84. Protecting yourself from AI fraud, fake calls, phishing and bogus job offers](https://studiomeyer.academy/playbooks/dich-vor-ki-betrug-schuetzen) [85. Opus 5 migration, when thinking becomes the default](https://studiomeyer.academy/playbooks/opus-5-migration) [86. The AI policy for small teams, on a single page](https://studiomeyer.academy/playbooks/ki-richtlinie-fuer-kleine-teams) [87. Stopping agents that drift off course](https://studiomeyer.academy/playbooks/agenten-die-abdriften-stoppen) [88. Seeing what your agent actually did, tracing in 10 steps with OpenTelemetry](https://studiomeyer.academy/playbooks/agent-tracing-mit-opentelemetry) [89. Having AI summarize long documents without it inventing things](https://studiomeyer.academy/playbooks/lange-dokumente-sicher-zusammenfassen) [90. Vetting third-party MCP servers safely before you install them](https://studiomeyer.academy/playbooks/fremde-mcp-server-sicher-pruefen) [91. AI as a learning coach: teaching yourself a new field for a career change](https://studiomeyer.academy/playbooks/ki-lern-coach-berufswechsel) [92. The AI operator job: what do you actually do?](https://studiomeyer.academy/playbooks/berufsbild-ai-operator) [93. Using AI without losing your own edge](https://studiomeyer.academy/playbooks/ki-nutzen-ohne-selbst-zu-verlernen) [94. Why your screenshot shrinks, and how to control it](https://studiomeyer.academy/playbooks/bilder-und-screenshots-an-die-ki-geben) [95. Framing a deep research brief so the report is actually worth something](https://studiomeyer.academy/playbooks/deep-research-auftrag-formulieren) [96. Analysing numbers and tables with AI without ending up with nonsense](https://studiomeyer.academy/playbooks/zahlen-und-tabellen-mit-ki-auswerten) [97. Reading AI benchmarks without being taken for a ride](https://studiomeyer.academy/playbooks/ki-benchmarks-richtig-lesen) [98. AI as a sparring partner, better decisions instead of polite agreement](https://studiomeyer.academy/playbooks/ki-als-sparringspartner-fuer-entscheidungen) [99. Learning a new skill with AI, the honest way](https://studiomeyer.academy/playbooks/mit-ki-neue-faehigkeit-lernen) [100. Changing your MCP server without breaking your users](https://studiomeyer.academy/playbooks/mcp-server-aendern-ohne-nutzer-zu-brechen) [101. Your first local AI model in 30 minutes](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten) [102. Which local model fits your hardware](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware) [103. Local AI and the GDPR, what it really solves and what it does not](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) [104. MCP with local models, tools without the cloud](https://studiomeyer.academy/playbooks/mcp-mit-lokalen-modellen) [105. Local or cloud, the honest arithmetic](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung) [106. When a stranger's repo configures your AI. The ChainDrop case](https://studiomeyer.academy/playbooks/agent-konfiguration-als-angriffsweg) [107. Transcribing conversations offline, without them leaving the building](https://studiomeyer.academy/playbooks/gespraeche-offline-transkribieren) [108. Connecting n8n to a local model](https://studiomeyer.academy/playbooks/n8n-mit-lokalem-modell-verbinden) [109. Reading documents offline when the scan must not be uploaded](https://studiomeyer.academy/playbooks/dokumente-offline-auslesen) [→ Zur Academy](https://studiomeyer.academy/levels/1)

## Sitemap

Public pages of this site as Markdown: [sitemap](https://studiomeyer.academy/sitemap.md). Curated entry point: [llms.txt](https://studiomeyer.academy/llms.txt), full text: [llms-full.txt](https://studiomeyer.academy/llms-full.txt).