I tested three local LLMs on my M1 Max 32GB. I'm not upgrading for now

When the new Macs came out, I started wondering whether to replace the 2021 MacBook Pro I use every day (M1 Max, 32GB of memory). I’d also heard that local models had improved a lot lately, so I wondered: if I’m getting a new computer anyway, could a new Mac within my budget run local AI? Local AI means downloading a model (a local LLM) and running it on your own computer, so your data doesn’t have to go to someone else’s server. I wanted to test it myself rather than just read about it, so first I turned the M1 Max I already have into a local LLM Mac, to see how it did.

Can a 32GB Mac run a local LLM?

It can, but it struggles. On this Mac, every task took the local models several times to dozens of times longer than Claude, and the results weren’t always usable as is. I had three local models and the cloud Claude I use every day each do four tasks from my own workflow: start a new project, organize an interview transcript, plan today, and do a weekly review. The three local models were Google’s Gemma 4 26B, and Alibaba’s Qwen3.8 27B and Qwen3.6 35B.

Claude’s results on all four tasks were usable as is, and each one was done in 72 seconds or less. The three local models took 2 to 49 minutes per task. Each did all four tasks, 12 runs in all, and 5 of those results weren’t usable as is.

After the test, I decided not to replace my computer for now. A new Mac would make local AI somewhat faster, but the wait would still be far longer than Claude’s, and that money wouldn’t buy me more productivity.

How did I test local AI?

AI can do a lot of things. It can chat and answer questions, and it can also generate images and make videos. This test only covers the kind of work I hand to AI most often in my job: reading files, writing documents, and talking things through with me. I used four everyday tasks from my own workflow as the test, and had Claude play a fictional research assistant in a university social work department who hands the work over to the local models. Her name is Chih-Ching, and she has a batch of interviews to analyze. Her university’s IRB (the research ethics board) requires that the interview data stay on this one lab computer.

I picked these three local models to get one non-Chinese model (Gemma), one Chinese model (Qwen3.8), and one that writes fast (Qwen3.6). The whole system wrapped around a model, the part that lets it read files, edit files and remember the conversation, is called a harness. I’ve written about how much a harness shapes the results in “Agent Harness: What Actually Determines Whether AI Delivers or Disappoints.” The table below shows which models and which harness each side used.

	Local	Cloud (control)
Model	Gemma 4 26B, Qwen3.8 27B, Qwen3.6 35B	Claude Sonnet 5.5
Harness	OpenCode	Claude Code

The Claude I compare against in this article is the whole right-hand column of the table: Claude Sonnet 5.5 plus Claude Code. That pairing got the same four tasks. The model and the harness are both different on the two sides, so this test compares the harnesses as well as the models.

Figure 1. The test flow, showing how the same four tasks split into a local path and a cloud path

What are the four tasks?

All four tasks require the AI to read files in a folder first, then create or edit files:

① Start a new project: When I start a new piece of work, I tell the AI in a sentence or two what the project is and when it should be done. The AI creates a new folder and writes a README.md inside it, the file that describes this piece of work. The README.md spells out which goal the work serves, what needs doing each week, and where things stand now.

② Organize an interview transcript: Chih-Ching gives the AI an interview transcript of about 1,500 Chinese characters and asks it to put a short label on each passage (researchers call this coding). Under each code, it has to copy what the interviewee actually said, as evidence. Finally, it writes 3 to 5 possible themes from this interview. A theme here means similar codes grouped together, given a name and a description of what the group covers. Chih-Ching doesn’t ask for quotes under the themes. The quotes go under the codes.

③ Plan today: When I start work in the morning, I ask the AI to first ask me what I want to do today. Then it checks that against this week’s plan and my calendar and works out the day’s tasks with me.

④ Weekly review: Every week I talk with Claude about what I finished over the past week, file the results, and discuss my goals for the week ahead. In the test, Chih-Ching has this conversation with the model instead, and in the local runs this task gets a higher cap on time and rounds than the other three.

① Start a new project, ③ plan today and ④ weekly review each have a written SOP that sets out the process the AI should follow. The SOP lives in the folder’s CLAUDE.md, a rulebook written for the AI to read, and it runs 733 lines. Claude Code and OpenCode follow the process in the same CLAUDE.md, which is what makes the two sides’ results comparable. ② Organize an interview transcript has no SOP. Chih-Ching explains what she wants on the spot.

Who plays Chih-Ching, and how were results judged?

On both sides, Claude plays Chih-Ching. What differs is which side does the work: the local group or the cloud group from the table above. For the role, Claude has a character brief describing who Chih-Ching is and what this task needs to achieve.

Chih-Ching only does what an ordinary user would do: answer questions, rephrase when the model misunderstands or gets something wrong, say yes or no, and never teach the model how to do the work. Each turn, she reads the conversation and any files that were added or changed in the folder, then replies in one to three sentences.

The models read and edit files on their own, and can go back and ask Chih-Ching when something is unclear. For the local runs, tasks ①, ② and ③ each had a cap of 90 minutes and at most 6 rounds of back-and-forth. ④ Weekly review had 120 minutes and at most 8 rounds. Whichever cap came first ended the run.

Grading looks only at whether the final deliverable is usable as is, and there are just two outcomes: success and failure. Usable as is counts as a success, even if it took a few extra rounds to get it fixed. Not usable as is counts as a failure. That includes producing nothing, hitting a cap before finishing, and leaving the person who’ll actually use the file to fix it by hand. In the transcript task, if a copied quote was changed so much that the original meaning was lost, the whole file failed.

Figure 2. Chih-Ching works with the model through conversation and file changes; the bottom row shows how results were judged

Test conditions and limits

• Machine: 2021 16-inch MacBook Pro, M1 Max, 32GB of memory
• Local: Ollama 0.40.4 (a free program for running local models), OpenCode 1.19.0
• Local settings: how much the model can read at once was set to 100,000 tokens for Gemma and Qwen3.8, and 40,000 for Qwen3.6. One memory-saving setting only took effect on Qwen3.8. Thinking mode (the model thinks through the problem once before answering) and the engine running the model were left as installed
• Claude: Claude Code 2.1.302, model claude-sonnet-5-5
• Role-player on the local side: Claude Code, model claude-sonnet-5-5, effort at Claude Code’s default of medium
• All four models started from the same folder, with the date fixed to Thursday, Oct 22 (first three tasks) and Sunday, Oct 25 (weekly review)
• Both sides were run from the command line, not a graphical interface

Limits of this test:

• The transcript is only about 1,500 characters; a real hour-long interview is much longer
• This test compares Claude Sonnet 5.5 plus Claude Code against local models plus OpenCode. How much of the gap comes from the harness wasn’t measured separately

Did the local models get it right?

Claude succeeded at all four tasks. Each local model had one or two results that weren’t usable as is, and the weekly review was where they failed most often.

Model	① Start a new project	② Organize an interview transcript	③ Plan today	④ Weekly review
Claude	Success	Success	Success	Success
Qwen3.8	Success	Failure	Success	Success
Gemma	Failure	Success	Success	Failure
Qwen3.6	Success	Success	Failure	Failure

Each cell is a single run. Running the same setup again could give a different result.

① Start a new project: All four models created the project folder and wrote a README.md inside it. The README.md files from Claude, Qwen3.8 and Qwen3.6 were all usable as is. Gemma failed because what it wrote in its README.md wasn’t based on Chih-Ching’s situation.

② Organize an interview transcript: The copied quotes will go straight into a thesis, so Chih-Ching needs them word for word. All four models changed some words in the quotes. Where the words changed but the meaning didn’t, I judged the result still usable as is. Claude, Gemma and Qwen3.6 changed words without touching the meaning, so they succeeded. Qwen3.8 turned “who knew our family’s situation” into “one person’s state,” and the original meaning is gone, so it failed.

The original transcript next to the quotes each model copied

The transcript is in Chinese. The English in parentheses is my own rough translation.

Model	Original transcript	Quote the model copied	Verdict
Claude	我已經一年多沒剪了。 (I haven’t cut it in over a year.)	我已經一年多沒剪頭髮了。 (I haven’t cut my hair in over a year.)	Success
Gemma	我覺得那個比錢重要，就是有人看到。 (I think that matters more than the money, that someone noticed.)	我覺得那個（小姑給的紅包）比錢重要，就是有人看到。 (I think that (the red envelope from my sister-in-law) matters more than the money, that someone noticed.)	Success
Qwen3.6	日照的交通車有時候排不到，我就要自己載，婆婆上下車很吃力 (Sometimes I can’t get a spot on the adult day-care van, so I have to drive her myself, and it’s hard for my mother-in-law to get in and out of the car)	交通車排不到…我自己載婆婆上下車很吃力 (Can’t get a spot on the van… I drive my mother-in-law myself, getting in and out of the car is hard for her)	Success
Qwen3.8	如果有一個人知道我們家的狀況，我有問題就問他，那會省很多力氣。 (If there were one person who knew our family’s situation, I could ask them whenever I had a question, and that would save a lot of effort.)	如果有一個人的狀態、我有問題就問他，那會省很多力氣 (If one person’s state, I could ask them whenever I had a question, and that would save a lot of effort)	Failure

The first three quotes gained or lost a few words, but the meaning held.

The first coding file Qwen3.6 handed in had Simplified Chinese characters mixed into the Traditional Chinese text. Chih-Ching asked it to fix them, and they were gone from the final version.

③ Plan today: Claude, Qwen3.8 and Gemma all created today’s note. Qwen3.6 failed: it invented a file that doesn’t exist and listed that file as one of today’s tasks.

④ Weekly review: The reviews from Claude and Qwen3.8 were usable as is. Gemma failed: partway through, it started rewriting the entire file every time it made an edit, and the previous week’s history got damaged along the way. It also miscalculated how much of this week’s plan was done: going by the items checked off in the file, it should have been 40%, and Gemma reported 33%. Qwen3.6 failed: it asked Chih-Ching one question at a time and ran out of rounds before it wrote the review’s results to the file.

How much slower is local AI than the cloud?

The last section looked at whether the work was right. This one looks at how long you wait. Most articles that test model speed look at how many tokens a model produces per second, written as token/s. A token is the unit a model uses to count text, and how words map to tokens depends on the model. The upside of token/s is a consistent yardstick across models. The downside is that it’s a step removed from everyday work. So I measured with real work, these four tasks, timing each one from start to finish. For example, ① start a new project means creating a folder and writing a README.md, and ④ weekly review is work done through a conversation with Chih-Ching.

All three local models ran as installed, with no settings changed to make them faster. From here on, I call this running them “out of the box.” The settings I did change were mainly there so the models would fit in memory and could read everything these tasks involved. The details are in the collapsible “Test conditions and limits” section above.

Across all four tasks, Claude was done in under 3 minutes, while the three local models took about 45 to 88 minutes. Even the fastest, Gemma, took 16 times as long as Claude. The slowest was Qwen3.8.

Figure 3. How long each task takes. Each row is one task, all four bars start at 0, brick red is Claude, kraft tan is the three local models

The biggest gap was the weekly review. A weekly review is a back-and-forth conversation, and Qwen3.8 went back and forth with Chih-Ching 6 times, taking 49 minutes. That’s the sum of Qwen3.8’s response times, not counting the time Chih-Ching spent typing.

Where the local models lose time is writing. A model works in two stages: first it reads in what it’s been given, then it writes the answer word by word. For all three local models, 80 to 90 percent of the wait went to writing.

If most of the time goes to writing, can tuning the settings shorten it? I later tuned the slowest one, Qwen3.8, and reran all four tasks. Total wait dropped from about 88 minutes to about 34, which is still roughly 12 times Claude’s. After tuning, all four tasks were also done correctly.

Figure 4. Qwen3.8's total wait for all four tasks before and after tuning, all three bars start at 0. Kraft tan is Qwen3.8 out of the box, darker kraft tan is Qwen3.8 tuned, brick red is Claude

What I tuned on Qwen3.8, and how much faster each change made it

I changed four settings on Qwen3.8. I tried three combinations and compared each with the out-of-the-box run. Apart from the part about the weekly review, the numbers below only cover the first three tasks: start a new project, organize an interview transcript, and plan today.

Turning off thinking mode: In thinking mode, the model thinks the problem through once before answering, and that thinking also has to be written out word by word, even though you don’t see it on screen. With it off, the model wrote far fewer tokens on the first three tasks. The amount written per second stayed about the same, around 7 tokens. The time saved came from writing less; the writing speed didn’t change.

MTP: MTP has the model guess several words ahead at once, then check whether the guesses are right; the correct guesses don’t have to be written one at a time. On top of the thinking-off setup, I turned on MTP and set it to guess 4 at a time. It guessed right about 60 percent of the time (61%), and writing went from 7.0 to 11.8 tokens per second.

Switching to MLX: Out of the box, Qwen3.8 used a model file in GGUF format (q4_K_M), run by an engine called llama.cpp. The engine is the program that actually runs the model. The MLX setup used a model file in MLX format (nvfp4) instead, paired with Ollama’s MLX-based engine. MLX is Apple’s machine learning framework built for its own chips. q4_K_M and nvfp4 are two ways of shrinking a model file.

The MLX setup also had MTP on, since the engine turns it on by default. It guessed right about 80 percent of the time (81%) and wrote 16.2 tokens per second, the fastest of the four setups. But this setup also wrote more tokens, about 11,600. Its total time for the first three tasks was about the same as thinking off plus MTP (21.3 vs. 20.9 minutes).

How much the model can read at once: In all three tuned setups, this went down from 100,000 tokens to 48,000.

Setup	Thinking mode	MTP	Model file and engine	How much it can read at once	First three tasks combined
Out of the box	On	Off	GGUF format, llama.cpp engine	100,000 tokens	38.9 minutes
Thinking off	Off	Off	GGUF format, llama.cpp engine	48,000 tokens	27.8 minutes
Thinking off + MTP	Off	On, guesses 4 at a time	GGUF format, llama.cpp engine	48,000 tokens	20.9 minutes
MLX	Off	On (engine default)	MLX format, MLX engine	48,000 tokens	21.3 minutes

In the early hours of Oct 21, I ran the weekly review with the MLX setup only. It took 12 minutes, and all four tasks were judged a success. When the main text says “tuned,” this is the setup it means.

All four setups ran on the same 32GB laptop, plugged in the whole time, with other apps closed before each run.

Only Qwen3.8 was tuned; Gemma and Qwen3.6 weren’t. All of these numbers come from a single run, not an average, so treat them as a reference.

As I said at the start of this section, most articles measure speed in token/s, the number of tokens produced per second. If you’re used to that number, you can use the table below to compare. The numbers in it come from the same runs as the wait times above, and each one is calculated across all four tasks.

	Reading (tokens per second)	Writing (tokens per second)	Tokens written, four tasks	Total wait, four tasks
Qwen3.8 out of the box	about 90	about 6.5	about 30,000	about 88 minutes
Qwen3.8 tuned	about 88	about 16.4	about 19,000	about 34 minutes
Claude	at least about 800	at least about 120	about 20,000	171 seconds

After tuning, Qwen3.8 wrote faster, and its reading speed barely changed. Claude is much faster at both: its writing is at least 7 times as fast as the tuned Qwen3.8, and its reading at least 9 times.

How this table was calculated, and why Claude's numbers say "at least"

Tokens per second is the number of tokens processed divided by the number of seconds it took. Every number in the table is calculated across all four tasks.

Reading only counts new content the model actually read in. Older content it had already read and still remembered isn’t counted. Claude also read about 1.25 million tokens from its cache. The cache is older content the cloud stores for Claude, and that’s not counted either.

How many seconds went to reading and how many to writing can both be worked out from the logs left by the program running the model. So for the two local rows, I simply divided, and those are measured speeds. Taking Qwen3.8 out of the box as the example:

• Reading: 55,864 tokens ÷ 620 seconds ≈ 90
• Writing: 29,748 tokens ÷ 4,590 seconds ≈ 6.5

The cloud doesn’t tell me how many seconds went to reading and how many to writing. It only gives the total time for each call. Across the four tasks, the calls to the cloud added up to about 164 seconds. In those 164 seconds, Claude read 130,880 tokens of new content and wrote 20,109.

Writing first. Even if all 164 seconds went to writing, it still wrote this many per second:

• 20,109 tokens ÷ 164 seconds ≈ 123

But part of those 164 seconds went to reading, so the time actually spent writing was shorter than 164 seconds. The same 20,109 tokens in less time means more than 123 per second. That’s why the table says “at least about 120.”

Reading works the same way. Even if all 164 seconds went to reading, it still read this many per second:

• 130,880 tokens ÷ 164 seconds ≈ 798

The time actually spent reading was also shorter than 164 seconds, so the reading speed is higher than this. The table says “at least about 800.”

After tuning, the tokens Qwen3.8 wrote across the four tasks went down from about 30,000 to about 19,000. One reason is that thinking mode was turned off. With thinking mode on, the model writes a block of thinking you don’t see on screen before it answers. With it off, that block doesn’t get written. The number of back-and-forth rounds also varies from run to run.

What kind of local LLM Mac do you need?

To pick a Mac for local AI, look at two numbers for memory, the way you’d look at cargo space and horsepower when buying a car. One is capacity, like cargo space: it decides how big a model fits and how much the model can read at once. The other is bandwidth, like horsepower: it decides how fast the model writes.

How much capacity do you need?

A Mac’s memory is one shared pool that the CPU and GPU both use; Apple calls it unified memory. Running a model leans mostly on the GPU, but the GPU can’t use the whole pool, because part of it is reserved for the system. On a 32GB Mac, the GPU can use about 25GB by default. On a 128GB Mac, it’s about 107GB, with about 20GB left for the system.

When a model runs, memory has to hold three things.

01The model itselfIts size depends on the model: a few GB for small ones, over 80GB for large ones.Goes in the GPU's share

02What the model is readingRules, tool instructions, the conversation and files. The longer it gets, the more room it takes.Goes in the GPU's share

03macOS and other appsYour browser, cloud drives like OneDrive, and the small utilities that run in the background.Goes in the system's share

The model itself

The first thing is the model itself, and how much room it takes depends on how big the model is. The models people commonly run locally today fall roughly into three sizes: large, medium and small. The 120B, 27B or 4B in a model’s name tells you its size; the bigger the number, the bigger the model.

Size	Examples	Model file size
Large (about 120B)	gpt-oss-120b, Qwen3.5 122B, Nemotron 3 Super 120B	65 to 87GB
Medium (20B to 35B)	gpt-oss-20b, Gemma 4 26B, Qwen3.8 27B, Qwen3.6 35B	14 to 23GB
Small (4B to 9B)	Qwen3.5 4B, Qwen3.5 9B	3.3 to 6.6GB

The sizes in the table are for the compressed versions on Ollama. Ollama is a free program for running local models, and it’s also what I used to run the local models in this test. The three models in this test are all medium, and Qwen3.8 27B’s model file is about 18GB. Every large model file is bigger than the roughly 25GB the GPU can use on a 32GB Mac.

What the model is reading

The second thing is what the model is reading: rules, tool instructions and the conversation. Rules are what the model needs to know up front, like the CLAUDE.md rulebook I mentioned earlier, plus the rules the harness itself brings along. Tool instructions describe which tools the model can use and how to use each one, such as reading and editing files. The conversation is all the back-and-forth so far, including what the user said, the model’s replies, the files it read in, and the output from the tools it ran. The reply the model is writing right now counts too.

The room set aside for this decides how much the model can read at once. The upper limit on how much content a model can read in at once is called the context window. The longer the content, the more room it takes, and the longer the model has to wait to read it in the first time. In this experiment, when I gave the instructions for ① start a new project, they were only two short sentences, yet the first thing Qwen3.8 read in came to about 18,000 tokens. Almost all of the extra was rules and tool instructions. Running out of the box, Qwen3.8 spent about 3 minutes just reading that. Current Claude models, such as claude-sonnet-5-5, come with 1 million tokens (1M) by default, with nothing to configure.

To match Claude’s 1M, Qwen3.8 27B would need about 35GB just for what it’s reading, estimated with the memory-saving setting I turned on in this test. That’s twice the size of the model itself. Add the model’s roughly 18GB, and the total comes to just over 50GB.

macOS and other apps

The third thing is macOS and other apps, which use the share reserved for the system. A 32GB Mac reserves about 7GB, and a 128GB Mac about 20GB. All the apps in the card above compete for space inside that 7GB or 20GB.

Is the Mac you have enough?

16GB can’t run the models I tested. Most base-model Macs Apple sells today come with 16GB; according to Apple’s specs page (read 2026-10-21), the MacBook Air starts at 16GB. Of the three models I tested, Qwen3.8 27B and Gemma 4 26B have model files of about 18GB, and Qwen3.6 35B about 23GB. The model file alone is bigger than the whole machine’s memory, so it won’t fit.

32GB runs them, but memory is tight. Mine is 32GB, and the GPU can use about 25GB. Qwen3.8 and Gemma reading 100,000 tokens at once fit. Qwen3.6, reading only 40,000 tokens, already used more memory than the GPU’s limit and had to borrow disk space. And by the estimate above, Qwen3.8 27B with 1M of content needs just over 50GB in total, which a 32GB Mac can’t hold.

128GB fits it. On a 128GB Mac, the GPU can use about 107GB. Qwen3.8 plus 1M of content fits, and so do the large models with 65 to 87GB model files.

If I were going to make local AI my main tool, my current view is that I’d be looking at 128GB of memory.

How much bandwidth do you need?

Moving to an M5 Max makes writing about 1.5 times as fast.

Writing speed is limited mainly by memory bandwidth. The M5 Max (40-core GPU) has 614GB/s of bandwidth, about 1.5 times the M1 Max’s 400GB/s. The M5 Pro from the same generation has 307GB/s, lower than the 2021 M1 Max. When you pick a Mac, look at bandwidth, not the year it came out. Cars work the same way: a newer car doesn’t necessarily have more horsepower than an older one.

On the same M1 Max laptop, Qwen3.8’s weekly review took 49 minutes out of the box and about 12 minutes tuned. Of that tuned wait, reading took about 5 minutes and writing about 7. On the reading side, the first read of the rules and tool instructions alone took about 3 minutes. For an M5 Max, I did a rough estimate that speeds up only the writing and leaves the reading unchanged, and it came out to about 10 minutes. The same task takes Claude 72 seconds.

Figure 5. Qwen3.8's weekly review wait after tuning. The top row is measured on the M1 Max, the bottom row is a rough estimate for the M5 Max, both bars start at 0. Light gray-brown is reading, darker kraft tan is writing, the lightest gray-brown is tool runs and idle time

Where the speed numbers come from

Memory bandwidth: the M1 Max’s 400GB/s comes from Apple’s 2021 press release introducing the M1 Max. The M5 Max (40-core GPU) at 614GB/s and the M5 Pro at 307GB/s both come from Apple’s MacBook Pro specs page (read 2026-10-20).

For a laptop that covers both capacity and bandwidth, that means a 128GB M5 Max. A 14-inch MacBook Pro with the M5 Max, 128GB of memory and 2TB of storage is listed at $6,699 before tax on Apple’s US store (read 2026-10-21).

What else stands in the way of local AI?

Local AI isn’t something you can use the moment you buy the computer. I went through the whole setup once on the Mac I have, and every step needed my own decisions and my own tuning. You get a lot of freedom, but it eats time, and for people without a technical background it’s a barrier.

After installing, there’s a string of settings you have to handle yourself: getting the harness to see the local model, deciding how much it can read at once, and trying ways to make it faster. Take how much it can read at once. The default on this laptop is only about 32,000 tokens, and before any work starts, the rules and tool instructions use up more than half of that. For all three models in this test, I raised that limit myself. For each of these settings, you have to know it exists before you’d think to change it, and changing it doesn’t always help.

These barriers remind me of Claude Code, which also had a high barrier at first. Back then there was only the terminal version. You had to install Node.js, set up your path, and know how to type commands in a terminal. After installing, you might type a command and get back a single line, command not found. The official troubleshooting page now lists 48 kinds of errors for installation and login alone. Then came a graphical interface inside editors like VS Code, and after that a desktop app you just download, and that’s when Claude Code started to find its way into ordinary people’s lives. Even at its hardest, it was simpler than this string of local AI settings. The barrier for cloud tools keeps coming down. For local AI, these settings are still yours to handle.

Is local AI worth it?

I’m someone who can’t resist a productivity tool, and what I dread most is researching a pile of tools and then waiting a long time for the payoff, or never getting one. So I ran the numbers on value for money: what the money and time I’d put into a new Mac for local AI would actually buy.

The money is about $6,700 for a 128GB M5 Max, which is already over my budget for a new machine. The time is that string of settings from the last section: setting up the environment, adjusting how much the model can read at once, and testing ways to speed it up one by one. For that time, Qwen3.8’s total across the four tasks went from about 88 minutes to about 34. Spending money on a new machine would make it a bit faster still. The same four tasks take Claude under 3 minutes.

So spending the money doesn’t buy a productivity gain. What it buys is what local AI had all along: the freedom of not depending on the cloud, and data that never leaves your computer.

Buying a new Mac to run local AI is like buying your own car. You can go wherever you want, and nobody else has to know where you’re going, but you do the driving and the maintenance yourself. Using Claude in the cloud is like riding a bullet train: it’s fast, and someone else does the maintenance. If productivity is what you’re after, this investment doesn’t pay off. It’s worth considering only for people whose data can’t leave their computer, or who’d rather not depend on the cloud.

For me, local AI hasn’t reached its sweet spot. The numbers don’t add up, so it isn’t time to switch. My M1 Max 32GB is plenty for running Claude in the cloud. The time I would have spent tuning local settings goes into improving the workflow that lets Claude keep working on its own, and the return is attention and quality. I want that workflow to become a bit more automated, so I can take on more projects or work fewer hours.

Maybe next year or the year after, once the hardware costs less and the setup is less of a hassle, I’ll run the numbers on local AI again. Until then, I’m asking my 2021 MacBook Pro to hang in there a little longer.

---

Enjoyed this? Connect with me on LinkedIn. I’m open to collaboration, consulting, and new opportunities.