DEV Community: Matt Macosko

Eight local AI agents on a Mac mini — and the product I'm building from them

Matt Macosko — Tue, 26 May 2026 19:04:03 +0000

A case study went around recently: a lawyer had wired up 66 AI agents on a Mac mini for his own firm — every one running locally, nothing touching a cloud API — and was looking for a commercial partner before releasing it as open source.

I read that and realized I had been building the same shape of thing for my own small business for the last year. Eight ambient agents, all running on Apple Silicon, none of them touching cloud APIs. I had not productized any of them. I had also not gotten paid for any of them.

This post is about what I'm doing about that.

The asset base

I shipped a repo called claude-code-local. It's an MLX server that wraps three local language models (Gemma 4 31B, Llama 3.3 70B, Qwen 3.5 122B MoE) behind an OpenAI-compatible API. The setup script picks the right model for your hardware, downloads it, and puts a launcher on your Desktop. Three commands and you're running a 31-billion-parameter language model on your MacBook.

It has 2,689 stars and 516 forks as of this writing. License is MIT. The whole thing is at github.com/nicedreamzapp/claude-code-local.

That's the engine. What I had not built was the funnel.

The gap that ate me for a month

Stars are people who think "I would love this." Forks are people who started doing the work. Neither converts to revenue.

Reading that case study, what jumped out was: a lawyer with the technical chops to wire 66 agents could not productize the result. He has the buyer relationships (he is the buyer); I have the go-to-market background (I've sold consumer hardware direct to customers for years). The intersection nobody is shipping is "Mac mini with this stack pre-installed, delivered to your law firm."

So I sat down and mapped what was actually missing.

The market gap, in numbers

I researched the on-device AI market for May 2026. Here is what I found:

Free OSS (Ollama, LM Studio, Jan, Atomic Bot, my own repo): saturated, no money flowing
Paid Mac App Store apps (Private LLM, Enclave AI, Local LLM): $10-30 one-time, real revenue for bootstrapped 2-person teams
Cloud SaaS with zero-data-retention (Spellbook, CoCounsel): $69-$149/mo per seat, cloud-not-local
Enterprise legal AI (Harvey): $1,200+/seat/month
AI-native law firms (Manifest, Avantia, General Legal): not selling tools, they ARE the firm

Two things stand out:

The gap between "free OSS" and "$1,200/seat SaaS" is not being filled by subscription products. Private LLM's App Store reviews explicitly call out "no subscription" as the reason buyers picked them. The privacy buyer rejects recurring billing for privacy software. This is not opinion; it is in their reviews.
The Mac mini hardware bundle for privileged work is being built privately but not productized. Nobody is shipping it as a SKU.

That is the gap. That is what I am putting a product against.

The ladder

I'm skipping the standard SaaS playbook because the market is telling me to. The privacy buyer rejects recurring billing — so the spine is one-time purchases, not subscriptions:

Rung	Price	Audience
Free repo	$0	Existing OSS audience, top of funnel
AirGap Box	$2,995 (Base) / $3,995 (Pro)	Small firms wanting sovereignty without DIY
Foundation consulting	scoped	Firms ready for deeper, white-glove deployment

The free repo gets you curious. The Box converts the firms who would rather pay $3k than learn MLX. Foundation is for the firms that want it installed, tuned, and documented for their compliance counsel.

The three core agents

Three agents that drop on top of any OpenAI-compatible local LLM server (the free claude-code-local repo by default, but they work with Ollama and others too) — and ship pre-installed on the Box:

Folder Watcher — drop a PDF, text, or Markdown file into ~/AirGap-Inbox/. Within 30 seconds, a structured Markdown summary appears in _summaries/. Uses macOS's textutil and mdimport for PDFs and docx without external dependencies.
Daily Briefing — every morning at 7:00 a LaunchAgent reads the folders you list in a config file and writes a one-page digest of what changed in the last 24 hours.
Local Q&A — a CLI command airgap ask "your question" that answers from a single document you point it at, fully offline. Folder-wide indexing and citations across many files is on the roadmap — not something I'd oversell today.

The whole set is ~300 lines of Python. The installer is a .command file you double-click. Total install time: under 60 seconds on the right hardware.

I deliberately built them with zero authentication required. No IMAP credentials, no OAuth dance, no API keys — the install works for everyone on day one. The agents that need credentials (email drafting, Reddit lurking, calendar parsing) run on my own machines and ship in the AirGap Box, where there's a setup call to wire them up properly.

What's in the AirGap Box

The same stack on a Mac mini that arrives at your office. Pre-installed: claude-code-local MLX server, the three core agents, two more that need credentials (email drafter, prompt library), a default-blocked firewall, and a printed compliance memo template.

Base ($2,995): Mac mini M4 16GB, Gemma 4 31B preloaded.
Pro ($3,995): Mac mini M4 Pro 24GB, Llama 3.3 70B preloaded.

Both include a 90-minute Zoom setup call and 30 days of email support. After that, you have a working private-AI workstation. We do not phone home. We do not see your data.

COGS on the base unit is around $940. Margin around 69%. Cash-flow safe because Stripe charges at purchase; hardware ordered after.

Validation before scale

I am not ordering inventory on speculation. The plan is:

Day 0: launch publicly, with the Box gated by a waitlist (no checkout yet)
Day 7: first review — Box waitlist signups
Day 14: hard gate on Box — 20+ verified emails or we revisit positioning
Day 30: full P&L review, decide whether to scale

If the Box waitlist hits 20 in 14 days, I order the first 3 Mac minis. If it hits 5, I have not validated the rung; I revisit positioning before spending hardware money.

This is the part the grifter posts skip. "I made $14,200/month in 72 hours" is not a thing that happens to honest businesses. What happens to honest businesses is "I opened a waitlist, watched signups for two weeks, decided whether to order inventory based on actual demand, and reported the real numbers."

Honest year-1 range

Month	Pessimistic	Realistic	Stretch
1	$0	$400	$2,000
3	$200	$1,500	$6,000
6	$800	$3,500	$12,000
12	$1,500	$6,000-8,000	$20,000+

To hit the grifter's $14k/month claim, every rung needs to perform near the top of its range AND consulting needs to land. That happens in months 12-18 with discipline, not in 72 hours.

What I will publish honestly

Weekly waitlist + signup numbers (real, not vanity)
The first refund (when it happens) and why
The first Box install case study (with the firm's permission)
The Box waitlist → order conversion, as it happens

If you want to see whether this business works, follow along on github.com/nicedreamzapp/claude-code-local and the AirGap landing pages. I'll post the numbers as they happen.

Why I'm posting this

Because the next person to read a case study like that and think "I want this" deserves to find a productized version, not another Hacker News thread about MLX setup. And because every honest version of this story I publish is also a receipt — for me, that I built something real, and for the next builder, that the playbook works.

If you have feedback on the pricing, the positioning, or the agents, leave a comment. I read everything.

I'm building AirGap — pre-configured local AI on a Mac mini for firms handling private work. Join the AirGap Box waitlist, grab the free open-source stack, or see AirGap consulting for compliance-sensitive firms (law, medical, finance).

Why I Quantize Open-Weight Models for Macs — And Why Your Law Firm Should Care

Matt Macosko — Fri, 22 May 2026 05:22:16 +0000

Every couple of weeks a new instruction-tuned model hits Hugging Face, and within hours the GGUF community has six variants up for llama.cpp users on Linux and Windows. The MLX community — the people running on M-series Macs — usually has to wait days or weeks, sometimes never.

I publish a few MLX quantizations a month under huggingface.co/divinetribe to close that gap. Two of mine have crossed 1,000 downloads in the last 30 days. The latest, Hermes-4-14B-abliterated-4bit-mlx, shipped today.

The downloads tell me something I already suspected: there is real, sustained demand for capable models that run entirely on Apple Silicon. And I think the most interesting buyers are not who you'd guess.

The hobbyist case is easy

Mac developers want models that "just work" on their hardware. MLX uses Apple's unified memory and Metal Performance Shaders. When a model lands in MLX format, inference goes from "this works through a compatibility shim" to "this is what the hardware was built for." Tokens-per-second jumps. Battery drain falls. The fan stays quiet.

That's fine. That's the easy demand to serve. Hobbyists, indie developers, students with M1 MacBook Airs. The downloads come in steady, and the audience expands a little every quarter.

The interesting case is law firms

Here's the part nobody talks about.

If you're a partner at a law firm handling NDAs, M&A docs, IP filings, sealed depositions — anything privileged — sending that content to OpenAI, Anthropic, or Google for "AI summarization" is, depending on your jurisdiction, somewhere between professionally negligent and outright disqualifying. The terms-of-service for every major cloud LLM provider explicitly retain the right to log your prompts. Many train on them. The opt-outs are partial at best and legally untested at worst.

So firms either:

Pretend AI doesn't exist (most do, currently)
Run an on-prem private cloud (six-figure setup, IT-heavy, hardware refresh every 18 months)
Use one of the "enterprise-grade" SaaS LLM wrappers that promises not to log (the promise is contractual, not technical)

Or — and this is the option that almost nobody is talking about — you put a MacBook Pro on the partner's desk, install a local LLM, point a chat client at localhost:8080, and the document never leaves the machine. Network-disconnect the laptop entirely during sensitive work, and you have a literal air gap. The prompt and the response live on a single piece of silicon owned by the firm.

That's not theoretical. I've built that exact stack — it's the AirGap AI consulting practice. The 14-day pilot ships claude-code-local (the on-device Claude Code replacement, currently 2,664 stars on GitHub) onto a firm-owned MacBook, with verified network audits proving nothing leaks. The models that run inside it are exactly the ones I publish on Hugging Face — Gemma 4 31B for everyday work, Llama 3.3 70B for harder reasoning, and now Hermes 4 14B for instruction-following without refusal noise.

The legal sector is the obvious first market, but the same pitch works for any field where confidentiality has teeth: medical records, due diligence, journalism source protection, internal investigations, M&A under embargo, defense contracting. Anywhere "your prompt cached on someone else's server" is a deal-breaker, an on-device MLX model is the answer.

Why open weights specifically

A cloud LLM is a black box. You send a prompt, the answer comes back, you trust that the provider isn't reading or training on it. The trust is enforced by a terms-of-service document and a privacy policy. If those change, your only recourse is to stop using the service. The content you already sent is, presumably, gone — but you have no way to verify.

Open weights flip that around. The model file lives on the firm's hardware. The firm's IT team can inspect every byte. Network monitoring tools can confirm that no inference traffic leaves the building. The model is auditable in a way no SaaS API will ever be. If the underlying open-weight model gets pulled from Hugging Face tomorrow, the firm's copy keeps working forever.

That permanence — the fact that today's open model is also next decade's open model, as long as someone keeps a copy — is the part of the pitch that I think clinches it for compliance officers. You can't subpoena Anthropic for a prompt you ran on your own MacBook in 2026.

What you can do with this

If you're a developer with a Mac, grab Hermes-4-14B-abliterated-4bit-mlx and try it. It's ~8 GB, runs on a 16 GB Mac, and the install is pip install mlx-lm plus three lines of Python. The model card has the recipe.

If you're a partner, IT director, or in-house counsel at a firm that handles privileged content, the AirGap AI pilot is the fastest path from "we're worried about AI confidentiality" to "we have a verified on-device setup." Two weeks, fixed scope, network audit included.

If you're a researcher or quant who wants the next model on Apple Silicon before anyone else has it, follow divinetribe on Hugging Face. The release cadence is irregular but the targets are deliberate — I publish what I'd actually want to use.

What this is not

I'm not anti-cloud. The frontier models from Anthropic and OpenAI are genuinely better at the hardest reasoning tasks, and for non-confidential work the cloud is the right default. I use Claude every day for my own coding.

I'm also not promising that local-first is free. There's a real cost to running serious local inference: hardware, electricity, the time to keep the stack updated. For most workflows the cloud is cheaper.

But for the cases where confidentiality is non-negotiable — and there are more of those than the AI industry currently admits — local-first is the only honest answer. Open weights, Apple Silicon, MLX. That's the stack. I'll keep publishing pieces of it on Hugging Face for as long as the downloads tell me people are using them.

Hermes-4-14B Abliterated, MLX 4-bit — Apple Silicon Just Got Another Real Model

Matt Macosko — Fri, 22 May 2026 05:20:56 +0000

When Babsie uploaded Hermes-4-14B-BF16-abliterated to Hugging Face yesterday, the only way to run it on a Mac was to download 28 GB of BF16 weights and feed them to transformers — which on Apple Silicon means falling back to PyTorch MPS, which is fine but not what the hardware was built for.

So I converted it to MLX 4-bit. ~8 GB on disk, runs at the speed Apple Silicon was actually designed for, and the model card is now live at:

huggingface.co/divinetribe/Hermes-4-14B-abliterated-4bit-mlx

Free, open weights, drop-in for any mlx-lm workflow.

What it is

Hermes 4 is NousResearch's instruction-tuned model family. The 14B variant is built on Qwen3, so it inherits Qwen3's tokenizer, chat template, and architectural quirks — but the post-training is pure Hermes, which means it's tuned for tool use, role-play, structured output, and not refusing benign-but-edgy questions.

Babsie's abliteration applies refusal-direction projection per Arditi et al. (2024) to the BF16 weights, which suppresses the model's built-in refusal vector. Plain English: the model will answer questions that the upstream Hermes would politely decline. You become the moderator.

My contribution is the boring-but-useful part: convert those BF16 weights to MLX, quantize to 4 bits with group size 64, ship.

Why this matters for Mac users

14B is the sweet spot on Apple Silicon. Big enough to be genuinely useful for instruction-following, small enough to fit comfortably in 16 GB of unified memory at 4-bit, and tiny enough on disk that you can keep a half-dozen variants without thinking about it.

For comparison:

Llama 3.3 70B 8-bit MLX (also on my Hugging Face) — 75 GB, needs a 96 GB machine
Gemma 4 31B 4-bit MLX — 17 GB, runs on any 32 GB Mac
Hermes 4 14B 4-bit MLX — 8 GB, runs on a 16 GB Mac, snappy on anything bigger

If you have an M-series Mac and you want a capable instruction-tuned model that doesn't refuse benign requests and doesn't phone home, this is the easiest install on the list.

How to run it

The mlx_lm package does all the heavy lifting. From a terminal:

pip install mlx-lm

Then, in Python:

from mlx_lm import load, generate

model, tokenizer = load("divinetribe/Hermes-4-14B-abliterated-4bit-mlx")

messages = [{"role": "user", "content": "Write a haiku about local inference."}]
prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)

response = generate(model, tokenizer, prompt=prompt, max_tokens=256)
print(response)

Or as a server, using mlx-lm's OpenAI-compatible endpoint:

mlx_lm.server --model divinetribe/Hermes-4-14B-abliterated-4bit-mlx --port 8080

That gives you a local http://localhost:8080/v1/chat/completions endpoint that any OpenAI SDK client can hit. No tokens, no API bills, no telemetry.

Where it slots into the local-first stack

I maintain claude-code-local on GitHub — a project that lets you run Claude Code 100% on-device using local MLX models in place of the Anthropic API. Hermes 4 14B abliterated is now a supported backend, sitting between Gemma 4 31B (the everyday workhorse) and Llama 3.3 70B (the heavy lifter) in terms of size and speed.

For workflows where refusals are noise (security research, fiction with edge, prompt-engineering experiments where the same prompt needs to hit both refusing and non-refusing models for comparison), the abliterated variant saves a lot of re-prompting.

Why I publish these

From where I sit, the Apple Silicon community is underserved on model variety. The big quantization shops mostly target llama.cpp and GGUF, which is fantastic for Linux/Windows GPU workflows but adds a translation layer on Macs. MLX is Apple's own framework, and when a model lands in MLX format the experience on a Mac goes from "this works" to "this is what the hardware is for."

So a few times a month, when a hot new model drops, I take the abliterated BF16 (if a trusted shop has done the abliteration upstream) and run it through mlx_lm.convert. Takes about an hour from git pull to huggingface-cli upload. Costs me ~80 GB of disk during the build and ~8 GB to keep around.

The downloads page tells me people are finding them. Llama 3.3 70B 8-bit MLX and Gemma 4 31B 4-bit MLX each pull ~1,000 downloads every 30 days, almost entirely from Mac users running them through mlx-lm or claude-code-local. Hermes 4 14B should be more accessible than either, since 16 GB Macs are everywhere.

What's next

I'm watching for the BF16 abliterated source of DeepSeek V4 Flash to drop publicly. The GGUF version (cyberneurova/CyberNeurova-DeepSeek-V4-Flash-abliterated-GGUF) already has 86 K downloads, but the BF16 source isn't published yet — the moment it lands, I'll be the first to ship an MLX 4-bit. DeepSeek V4 Flash on Apple Silicon at ~140 GB is going to be a moment for people with 128 GB+ Macs.

Until then: enjoy Hermes 4 14B. The model card has the full install recipe and a benchmark snippet.

504,571 Brain Cells, 4 Labs, One Hypothesis: A Citizen Pass at Parkinson's

Matt Macosko — Fri, 22 May 2026 02:03:23 +0000

Watch the companion video — narrated walkthrough of the meta-analysis

I want to say upfront that I am not a neuroscientist. I run a small company in Humboldt County, California, and most of my days are about shipping orders and writing code. But over the last few weeks I spent my nights pulling down four public single-cell RNA datasets and running the same statistical pass across all of them, and the result was clean enough that I think it is worth talking about.

The short version: when you pool 504,571 single-cell measurements of human midbrain tissue from four different research groups, one specific subtype of dopamine neuron — the cells that express the angiotensin II type 1 receptor, AGTR1 — is depleted in every single Parkinson's dataset compared to controls. Combined odds ratio 0.215. P-value less than 10 to the negative one hundredth power. That is not a marginal effect. That is one of the most depleted druggable cell types I have ever seen reported, and the receptor is already targetable by FDA-approved blood-pressure drugs that have been on the market for thirty years.

That is the headline. Here is the longer story of how I got there, what I think it means, and — more importantly — what I do not think it means, because the easiest way to embarrass yourself in a field you do not belong to is to overclaim.

Where the idea actually came from

I did not discover this. Tushar Kamath and his colleagues at the Broad Institute published the original observation in Nature Neuroscience in 2022. They ran single-nucleus RNA sequencing on postmortem human midbrain tissue from Parkinson's patients and controls, and they noticed that one subtype of dopamine neuron — defined by the markers SOX6 and AGTR1 — was preferentially lost in disease. It was a careful paper, peer-reviewed, well-cited. It did the science. What it did not do, and what no single study can ever do, is rule out the possibility that the effect they saw was an artifact of their particular cohort, their particular dissection protocol, or their particular sequencing chemistry.

That is what meta-analysis is for. You take the same biological question and you ask it of as many independent datasets as you can find. If the effect is real, it shows up across cohorts. If it is artifact, it washes out.

I am a hobbyist in this field, but I am not bad at this part of it. I have spent the last year teaching myself single-cell analysis on the side. I knew that since Kamath 2022, three more independent groups had released public single-cell Parkinson's datasets — Smajić et al. at DZNE in Germany, Wang et al. at Mount Sinai, and Martirosyan et al., an independent cohort released in 2024. None of them, as far as I could find, had run the AGTR1 question across each other's data. So I did.

What I actually ran

The pipeline is unsexy. Python, scanpy, statsmodels. Pull each dataset from GEO. Normalize. Run the same cell-typing logic on each one so the labels are consistent across studies. Count the fraction of dopamine neurons in each donor that fall into the AGTR1-positive subtype. Compare patients to controls. Pool the four resulting odds ratios using fixed-effect meta-analysis with effect-size weighting.

That is it. There is no fancy machine learning, no transformer, no proprietary model. The whole repository is a few thousand lines of straightforward bioinformatics that anyone with a laptop can rerun. I made sure of that on purpose. The code is on GitHub, the data is public, the figures are reproducible end to end with a single shell script.

The four-cohort breakdown looks like this:

Dataset	Source	Year	Cells	Control AGTR1+ fraction	PD AGTR1+ fraction	Odds ratio
GSE184950	Mount Sinai	2022	12,778	3.31%	1.00%	0.295
GSE178265	Broad Institute	2022	366,874	3.30%	0.60%	0.177
GSE157783	DZNE Germany	2022	41,435	3.30%	1.00%	0.296
GSE243639	Independent	2024	83,484	2.96%	0.89%	0.295

Every single one points in the same direction. Every single one. The combined odds ratio of 0.215 means roughly a 78 percent reduction in this cell type in Parkinson's brains across half a million cells from four independent cohorts run by four independent groups using slightly different protocols. That is the kind of consistency you almost never see in a noisy field like single-cell genomics, and it is the kind of consistency that — if I were a real neuroscientist running a real lab — would make me drop my other projects and chase this.

Why this could actually matter

AGTR1 is the receptor that angiotensin II binds to. It is the same receptor that gets blocked by the entire class of drugs called angiotensin receptor blockers — ARBs. Losartan. Candesartan. Telmisartan. These are some of the most widely prescribed blood-pressure drugs on Earth. They have been FDA-approved for decades. Their safety profile is extremely well characterized. Several of them cross the blood-brain barrier in measurable amounts.

There is already a small body of epidemiological literature suggesting that long-term ARB users have a lower risk of developing Parkinson's. There is animal-model work showing that ARBs are neuroprotective in MPTP and 6-OHDA mouse models of Parkinson's. There is a 2025 iPSC paper showing that pharmacological inhibition of AGTR1 is pro-survival in human dopamine neurons in a dish. None of this is brand new. What I think is new is the cleanly meta-analyzed cross-cohort confirmation that the cells that get lost in Parkinson's are exactly the cells that express the receptor those drugs hit.

If a clinical trial were ever run — and I am not in any position to run one — the hypothesis would be: in early-stage Parkinson's patients, does adding a brain-penetrant ARB to standard care slow the rate of dopaminergic decline? It is the kind of trial that, on paper, costs maybe a few million dollars instead of the half-billion that a brand-new drug would cost, because the drugs already exist and are already off-patent.

I am genuinely hopeful that someone with the credentials to do this picks it up.

What I want to be very careful not to claim

I am going to say this part plainly because I have watched too many people in adjacent fields ruin their credibility by overclaiming. So, what this analysis does not do:

It does not prove ARBs treat Parkinson's. A retrospective bioinformatics finding is a hypothesis-generation step. The wet lab is where biology actually gets tested. Until somebody runs a real trial in real patients, this is a target that looks promising on paper, nothing more.

It does not establish causality. AGTR1-positive neurons being depleted in Parkinson's brains tells us they are vulnerable. It does not tell us why. It could be that AGTR1 signaling itself drives their death, in which case blocking it should help. It could also be that something else is killing them and AGTR1 is just a marker of a particular cell type that happens to be vulnerable for some other reason entirely, in which case blocking AGTR1 might do nothing. Wet lab work is the only way to distinguish those two possibilities.

It does not mean I am right and the field has missed something. The field has not missed this. Kamath saw it in 2022. Several groups have followed up. What might be missing — and where I think a citizen-analysis approach actually adds value — is the rigorous cross-cohort confirmation in a single place that anyone can reproduce. That is the thing I can contribute as a hobbyist. The hard biology is somebody else's job.

Why I am publishing this

A few reasons.

Mainly, I think this is what open science should look like. The datasets are public. The code is public. The methods are standard. The result is checkable in an afternoon by anyone who downloads the repository and runs the shell script. If I made a mistake, I want someone to find it and tell me. If I did not make a mistake, I want the people who can move this forward — neuroscientists, immunologists, drug-discovery teams, clinical trialists — to know it is there.

Also, honestly, because the more I read about Parkinson's the more I understand that it is not a far-off problem. About a million people in the United States are living with it right now. The diagnosis rate is rising. The treatments are decent for the early symptoms and bad for the long-term ones. The next breakthrough is not going to come from one person. It is going to come from a lot of small, well-aimed contributions stacking up. I would like this to be one of them.

If you are a neuroscientist, a clinician, an immunologist, a drug-development researcher, or a Parkinson's advocate and any of this lines up with something you are working on — I would genuinely love to hear from you. The repository has a contact section.

The repository: https://github.com/nicedreamzapp/parkinsons-vulnerability-predictor

Companion video walking through the full meta-analysis in about a minute: https://youtu.be/bC4hgeHS9cg

I will keep working on this. The next pass is going to look at whether the AGTR1 effect tracks with disease severity within each cohort, and whether the same signal shows up in Lewy Body Dementia, which shares biology with Parkinson's. If anything interesting comes out, it will go up on the same repository, in the open, with the code attached.

Thanks for reading.

— Matt

Companion video on YouTube: https://youtu.be/bC4hgeHS9cg. Full reproducible repo: https://github.com/nicedreamzapp/parkinsons-vulnerability-predictor. I run Nice Dreamz LLC and consult on private/local AI for compliance-sensitive firms via AirGap AI.

I Just Watched One Hacker Catch Up to a Trillion-Dollar Data Center

Matt Macosko — Sun, 10 May 2026 05:16:13 +0000

▶ Watch the companion video — three engines, one prompt, one MacBook

Yesterday Salvatore Sanfilippo — the guy who wrote Redis 15 years ago and ran it solo for over a decade — published a few thousand lines of C code and quietly changed what counts as possible on a personal laptop.

The project is called ds4. It's a hand-written native inference engine, Metal kernels and all, built for one specific model: DeepSeek V4 Flash. A 284-billion-parameter Mixture-of-Experts model with a 1-million-token context window. Until last week, that lived inside the kind of GPU clusters that bill more per hour than my truck.

I'm running it on the laptop I'm typing this on.

What I actually did

Today I gave the same prompt to three different AI engines. The same prompt, on the same MacBook:

"Build an animated northern lights scene in a single HTML file — mountains, pine trees, twinkling stars, and a flowing aurora."

Three engines:

DeepSeek V4 Flash running locally through ds4
Cloud Claude through my Max plan, hitting Anthropic's data center
Gemma 4 31B running locally through MLX

Then I watched what came out.

Engine	Time	Output	Hosted on
DeepSeek V4 Flash (ds4 local)	103 s	3,259 tokens	my laptop
Cloud Claude (Max plan)	192 s	~3,500 tokens	Anthropic's GPUs
Gemma 4 31B (MLX local)	131 s	1,992 tokens	my laptop

Local-first DeepSeek beat cloud Claude on raw wall-clock time. Let that one sit for a second.

What the auroras actually looked like

Three completely different interpretations of the same prompt — which is the part that surprised me.

DeepSeek's aurora was a flowing ribbon of teal and lavender drifting over a dense pine forest. The trees got a subtle green underglow from the sky. Most cohesive of the three.
Cloud Claude's went the most cinematic — magenta and teal aurora bands draped across jagged mountains, with a soft luminescent dusting along the peaks. It looks like a desktop wallpaper.
Gemma's went minimalist — a single sweeping streak of green and violet against a starry sky, with a clean line-drawing mountain silhouette. Stylized, almost graphic.

Each one runs forever. None of them needed a network call.

What this means for the cloud AI bill

I've written before about how my Claude Max plan returns roughly 40x value compared to API rates. That math is still true. Anthropic is still subsidizing the difference.

But this changes the calculation. If the cloud got expensive tomorrow — or if my data needed to stay on-device — I now have a credible escape hatch. Not "good enough for testing." Actually frontier-class. Actually long context. Actually integrated with Claude Code.

The hybrid is what I'm settling into:

claude for the hardest reasoning tasks I do all day
claude-ds4 for routine work, long-context document review, and anything I'd rather keep on this machine

The meter at the top of my screen no longer goes up for most of what I do.

Three things `ds4` does that nobody else has bundled

Asymmetric 2-bit quantization. Only the routed Mixture-of-Experts experts get compressed to 2-bit — about 90% of the weight footprint. Every quality-critical path (shared experts, attention projections, output head) stays at full precision. The result is an 81 GB file that calls tools cleanly.
KV cache moved to disk. Modern Apple SSDs are fast enough that "the KV cache must live in RAM" is just no longer true in 2026. ds4 writes session state to disk and reuses it across restarts. The first 25k-token Claude Code system prompt gets prefilled exactly once, ever, and replays from cache after that.
Pure Metal native code. No PyTorch, no TensorFlow, no llama.cpp wrapper layer. The hot path is Metal compute kernels written for one specific 284B model. M3 Max gets ~27 tokens/sec; M5 Max hits ~32.

What I'm doing next

The voice agent stack I've been building — wake-word listening, voiceprint filtering, transcripts piped straight into Claude Code — has been waiting for exactly this. Cloud Claude was good enough to test with, but routing every utterance through someone else's API meant every long agent run had a meter on it.

This week the meter goes away. Same agent, same tools, same cloned voice — running on a single laptop, off-cloud, with a context window five times longer than what I had on the Max plan.

I'll write that one up next.

For now, if you've got 128 GB of RAM and a free hour: clone antirez/ds4, run make, run ./download_model.sh q2, and see for yourself.

May 9, 2026. The day a single C file caught up to the data centers.

Companion repo: github.com/antirez/ds4 · Hugging Face weights: antirez/deepseek-v4-gguf · Model card: deepseek-ai/DeepSeek-V4-Flash · Companion video: [YouTube link TBD]

Companion video on YouTube: https://youtu.be/7l8-s8xkpms. For local-AI consulting for compliance-sensitive firms (law, medical, finance), see AirGap AI.

HumanEval on a MacBook — 81.7% pass@1, Wi-Fi off

Matt Macosko — Wed, 29 Apr 2026 18:11:49 +0000

The M5 Max MacBook Pro with 128 GB of unified memory is the first laptop that can hold a frontier-class coding agent entirely in RAM. No GPU rack. No cloud. No subscription.

I just ran HumanEval on it. Wi-Fi off the entire run.

81.7% pass@1 on the full 164-problem benchmark
Qwen 3 Coder 30B-A3B-Instruct (8-bit MLX)
14 minutes wall-clock, $0/month after the model download

YouTube walkthrough (three real problems, code streaming live, tests going green):
https://www.youtube.com/watch?v=muq7VdgxqRk

Why this number matters

The Qwen team didn't publish HumanEval scores for any Qwen3-Coder variant — they consider the benchmark saturated and went straight to agentic ones (SWE-bench Verified, BFCL, Aider-Polyglot). For the 30B variant — the one that actually fits on a laptop — there were no published HumanEval/MBPP numbers. Until this run.

I also ran MBPP (sanitized): 83.3% pass@1 on a 168-problem sample. Pass rate stable since n=120; full 427-run was impractical because a few outlier tasks induce very long model responses (10+ minutes each).

Methodology

Setting	Value
Benchmark	HumanEval — 164 Python tasks (full)
Metric	pass@1 (first attempt only)
Temperature	0.0 — deterministic
Sampling	single sample per problem, no best-of-N
Execution	Python subprocess, 10s timeout
Hardware	M5 Max MacBook Pro · 128 GB unified memory
Model	Qwen3-Coder-30B-A3B-Instruct-MLX-8bit
Network	Wi-Fi OFF the entire run
Wall clock	14 minutes

For context — Qwen3-Coder 480B's official agentic benchmarks

The Qwen team's published numbers for the 480B flagship sibling (the bigger sibling of the 30B running on this MacBook):

Benchmark	Qwen3-Coder 480B	Claude Sonnet 4	GPT-4.1
SWE-bench Verified (500-turn)	69.6	70.4	—
Terminal-Bench	37.5	35.5	25.3
BFCL-v3	68.7	73.3	62.9
Aider-Polyglot	61.8	56.4	52.4

Source: Qwen team's official blog.

Why the offline part matters

If a tool needs the internet, three things are true:

Someone else can read what you sent.
Someone else can charge you for it.
Someone else can take it away.

If the same tool runs locally, none of those are true. That's a different category of software — and for law firms, medical practices, and accountants handling client material, it's the only legal one.

Reproduce it yourself

Open-source launchers: github.com/nicedreamzapp/claude-code-local
HumanEval dataset: github.com/openai/human-eval
Hardware: any M-series MacBook with ≥32 GB RAM (128 GB Max preferred for full 8-bit weights)
Total monthly cost: $0 after the model download

For law firms, medical practices, and accountants who want help getting this stack running on their own hardware — that's what AirGap is. 14-day pilot, fixed scope, the data never leaves your machines.

— matt

Originally published at Marijuana Union. For premium vaporizers visit iNeedHemp, wholesale at Nice Dreamz, and seeds at Tribe Seed Bank. Explore the 3D cannabis marketplace at The Farmstand.

Pulling 10x My Subscription Value Out of Claude — While Quietly Building the Backup Plan

Matt Macosko — Sun, 26 Apr 2026 18:06:41 +0000

The math, visualized: every blue bar is one day's API-equivalent token consumption. The green dashed line at the bottom is what I actually paid (pro-rated). April 14 alone — $454 in one day — was more than four months of subscription.

Every Sunday night I watch the meter tick toward 100% again. That's been the rhythm for months — five days of heavy work, one day of cleanup, one day of waiting for the weekly reset. I'm on Claude Max — usually the 5x tier at $100 a month — and I burn through nearly every token they give me.

Out of curiosity I ran the math last week. I'm not sure I should have.

Over the last three weeks, the tokens I've put through Claude Code added up to about $2,976 worth of API usage at Anthropic's published rates. Pro-rated, my subscription cost over that same window was about $70. One Tuesday in mid-April, I spent $454 of token-equivalent value in a single day — more than four months of subscription, in one sitting.

The math doesn't quite work. Which is exactly what I want to talk about.

The honest comparison

If I were paying per-token through the API to do the work I'm doing — coding, writing, agent loops, the whole pipeline — I'd be looking at roughly $1,000 a week at the rate I'm running. The 5x Max subscription pro-rates to about $23 a week.

That's a ~40x multiplier. The headline says 10x because I wanted to be conservative. The real number is about four times that.

Why is Anthropic eating the difference?

This is the part I keep turning over. Anthropic isn't a charity — they have GPU bills, payroll, and investors who eventually want margins. So why hand power users $1,000 of compute for $23 a week?

From where I sit, three reasons line up:

Habit formation beats price optimization. A heavy API user shops on price every quarter. A subscriber builds workflows, custom agents, deep tool integrations — and wakes up two years later unable to leave. Subscriptions are sticky. API calls are mercenary.

Predictable revenue is worth a discount. Investors love subscription math. $100/mo × 100,000 power users is a number you can model. Lumpy API usage isn't.

Land-grab while the war is hot. OpenAI, Google, and Anthropic are all fighting for the same developer seats right now. Subsidizing the heavy users means those users go tell other developers "you have to try this." I've done it myself a dozen times. That word-of-mouth is cheaper than ads.

So the subsidy is rational. It's also temporary.

The tells it's already tightening

A year ago there were no weekly limits on Claude Pro or Max. The tier was straightforward: pay, use it. Now there's a weekly cap that resets on a rolling schedule, and Opus has its own quota separated from Sonnet.

That's the rug being pulled tighter, one notch every few months. Anyone who's watched this pattern in cloud services or streaming knows where it ends — not with the deal disappearing, but with the deal getting expensive enough that you have to think before you use it. I'd rather adjust now than be surprised.

What I built quietly on the side

I love Claude Max. I'd be foolish not to. But I wouldn't bet my business on a subsidized line item with a tightening cap, so I built insurance.

My primary machine is an M5 Max MacBook Pro with 128 GB of RAM. On it I run Gemma 4 31B as my daily local driver — fast, capable enough for editing and routine code work, and it doesn't phone home. The bigger picture is a three-node mesh: the M5 as workstation, a Mac Mini as workhorse, and a small VPS as the gateway. Voice cloning, content drafting, simple agent loops — those run locally now.

They're not as smart as Opus. They don't need to be. The split: cloud Claude does the hard, frontier-grade thinking. Local models do the steady-state work — the kind that, if Anthropic doubled prices tomorrow, I wouldn't want to be paying premium rates for anyway. I'd rather pay once for hardware I own than be one pricing email away from a forced workflow change.

The honest takeaway

Right now is one of the strangest pricing windows in software history. You can rent the most capable AI on the planet for less than a decent meal out and use it like a senior engineer who never sleeps. Use it hard, build the workflows, learn everything the subsidy will let you.

The people still working at this pace in eighteen months won't be the ones who picked a side. They'll be the ones running both — getting maximum leverage from cloud Claude while making sure their work doesn't depend on it lasting.

Forty times my money's worth. I'm grateful. I'm also paying attention.

Matt Macosko runs Divine Tribe and Nice Dreamz LLC out of Northern California. He writes about local AI, ambient computing, and what it actually takes to run a small business with frontier-grade tools.

Originally published at Nice Dreamz Wholesale. For local-AI consulting for compliance-sensitive firms (law, medical, finance), see AirGap AI.

Free AI on a MacBook vs $100-a-Month Claude Code — Hexagon Shootout

Matt Macosko — Thu, 23 Apr 2026 04:32:47 +0000

▶ Watch the race on YouTube: https://www.youtube.com/watch?v=2KeTDDodE0A

April 22, 2026. Anthropic's Claude Code Max plan jumped to $100 a month. I ran a live three-way AI race on the exact same prompt — Gemma 31B local, Llama 70B local, and Claude cloud — on a single MacBook, to see how close a free local stack gets to the paid cloud. Two of three contestants finished with zero cloud calls.

If you just want the video, it's here: FREE AI on a MacBook vs Claude Cloud — Hexagon Shootout.

If you want the repo, it's here: github.com/nicedreamzapp/claude-code-local.

Keep reading for the setup, the numbers, and the three things that surprised me.

The setup — same prompt, three contestants

Hardware: M5 Max MacBook Pro, 128 GB unified memory, Apple Silicon.

Gemma 31B — local, Apple MLX, 4-bit quantized (Google's code-specialized model)
Llama 70B — local, Apple MLX, 8-bit quantized (Meta's generalist)
Claude cloud — the real Anthropic API, using Claude Code unchanged

Same prompt to every contestant:

Build a single HTML file with inline JavaScript that shows a ball bouncing inside a rotating hexagon. Include gravity and realistic bounce physics.

Simple enough that the answer should be a few kilobytes of code. Interesting enough that it exposes how well a model handles real math — collision detection against rotating geometry, energy conservation, boundary clamping. When models trip, they trip here.

Every run was recorded end-to-end with a live stats panel: elapsed seconds, output bytes, tokens-per-second. No cherry-picking, no post-hoc edits to the physics code, no "here's what it SHOULD have said." What you see is what came out.

The results

Contestant	Time to ship working HTML	Tokens/sec	Cloud calls
Claude cloud	22 s	N/A (data center)	yes (via API)
Gemma 31B local	56 s	~30	zero
Llama 70B local	2:17	~11	zero

Claude cloud finished first — it's a data center somewhere. Gemma 31B finished clean in under a minute with working physics. Llama 70B took the longest and produced the most verbose output, but also landed a working demo in the end.

The headline isn't that one is "best." It's that two of the three ran with Wi-Fi that could have been off the entire time. That's the number that matters for anyone dealing with NDAs, PHI, client files, or just a flight without connectivity.

Three things that surprised me

1. Bigger isn't better when "bigger" is a generalist

I went in expecting Llama 70B to beat Gemma 31B on code quality. It's more than twice the parameter count. Gemma beat Llama cleaner and faster on this specific task.

Why: Gemma 4 is a Google model fine-tuned heavily for coding and math. Llama 3.3 70B is Meta's generalist — it's excellent at conversation, reasoning, creative writing, but it wasn't tuned to punch above its weight on HTML canvas physics.

If you're buying a local model for coding, you're better off with a 30B that's code-tuned than a 70B that's general. Don't count parameters, read the model card.

2. Claude Code's harness chokes local models

Claude Code (the CLI agent) sends a 29,000-token system prompt with 60 tool schemas in every request. That's tuned for the cloud — where a frontier model can happily chew through 30K tokens of context before even starting. On a local 70B, that prefill takes a minute or two before generation begins.

When I bypassed Claude Code and hit the MLX server directly with just the prompt, Llama 70B's wall-clock time dropped from 7+ minutes to under 2.

The tradeoff: without Claude Code's harness you lose the Write/Edit/Bash tool-use loop, so you can't use Claude Code as an agent, only as a generator. For research, benchmarking, or any single-shot prompt, direct is way faster. For actual coding sessions, the overhead is real but it's what buys you the agent loop.

3. Circle-approximation collision is the cheat code

All three models eventually produced a bouncing ball. The ones that worked used circle-approximation collision — treat the hexagon as a circle of its apothem radius for collision purposes, reflect velocity when the ball exceeds that radius, clamp the ball back to exactly inside. Five lines of math, reliable, hexagon can rotate as wildly as you want.

The ones that failed tried to do proper polygon-edge collision — compute the six edges of the rotating hexagon each frame, compute point-to-line distance for each, reflect off the appropriate edge. That's the "right" way, and it fails constantly because floating-point error lets the ball slip through edges during the rotation, and then the model doesn't know how to clamp it back.

I wouldn't have predicted this. The "simple" approximation is strictly better for the demo because it can't leak. For anything more complex than one ball, the polygon approach is necessary — but for a benchmark, approximation wins.

Who should care

Developers on laptops with 64+ GB of Apple Silicon unified memory: you can run this today, your hardware already supports it.
Anyone dealing with confidential work — lawyers, accountants, doctors, contractors handling NDAs or PHI: the cost isn't $0 vs $100, it's "does your data leave the machine" vs "does it not."
Frequent flyers and people who travel to places with bad internet: a 70B model on a laptop keeps working when the plane's Wi-Fi is $18 and throttled.
Anyone curious whether Apple's bet on unified memory was actually about AI: it was.

How to run it yourself

The repo is MIT licensed and open source. Full setup is in the README:

→ github.com/nicedreamzapp/claude-code-local

The project pairs a native-MLX Anthropic-API-compatible server with Claude Code. Point Claude Code at localhost:4000 and the official CLI talks to your local model as if it were the cloud API. Swap models with one env var. Ship code without the subscription.

Around 2,000 stars in the first month. If it's useful, a star helps.

TL;DR

Claude cloud: $100/mo, 22 seconds to a working hexagon.
Gemma 31B on my MacBook: $0, 56 seconds to a working hexagon.
Llama 70B on my MacBook: $0, 2:17 to a working hexagon.
Two of three ran with zero cloud calls.
Free AI on Apple Silicon is real, now, for a huge slice of what people use cloud APIs for.

The receipts, in video form: youtube.com/watch?v=2KeTDDodE0A

Originally published at Marijuana Union. For premium vaporizers visit iNeedHemp, wholesale at Nice Dreamz, and seeds at Tribe Seed Bank. Explore the 3D cannabis marketplace at The Farmstand.

The Era of Hunched-Over-A-Screen Computing Is Ending — Heres Whats Replacing It

Matt Macosko — Wed, 22 Apr 2026 09:54:00 +0000

Look around any coffee shop, any office, any living room. Everyone is bent forward at the same angle, staring into a glowing rectangle, with one hand on a small slab and the other on a bigger slab. The whole posture is wrong. We know it’s wrong — that’s why ergonomic chairs are a $2 billion industry — but we keep doing it because the computers we built require it.

I think we’re at the end of that era. Not because somebody invented a magic new screen. Because computing itself is finally able to leave the rectangle.

I call what’s coming ambient computing. The phrase isn’t new, but most uses of it are about smart speakers or watches — small devices that ask you to look at them too. That’s not what I mean. I mean a way of working with computers that doesn’t require you to face a screen at all. Where the machine listens, talks back, sees what you see, and the keyboard becomes optional rather than mandatory.

The pieces of it are already shipping. They just haven’t been assembled.

What ambient computing actually looks like

Sitting in a hot tub a few weeks ago, I sent a text from my phone: “find me the best rated electric guitar at this price range, screenshot it, and text it back to me.” Two minutes later my phone buzzed with the screenshot. The Mac on my desk had searched, found, captured, and sent back, while I stayed in the tub.

That’s an ambient-computing moment. No screen. No keyboard. The computer was a participant in what I was doing rather than the thing I had to stop and walk over to.

The same week, I had a hands-free coding session — speaking into the room, hearing a cloned version of my own voice narrate what the AI was doing, course-correcting verbally. No mouse. No keyboard. No screen-watching. The work got done. The AI told me when it was done. I went on with my day.

Both of these worked on hardware I already owned. A MacBook Pro on the desk. An iPhone in my pocket. The pieces that turned them into an ambient system are open source and free.

Three pieces that already exist

1. Local AI. A current MacBook Pro can run a 70-billion-parameter language model entirely on the GPU side of its unified memory. That model is good enough to write code, draft documents, summarize content, and run multi-step tool-using workflows. It does this with no internet and no subscription. The model lives on the machine; the inference happens on the machine.

The fact that this is true on consumer hardware is a recent development. It wasn’t true two years ago. And it’s the foundation of everything else.

2. On-device speech. Apple’s SFSpeechRecognizer — the same engine that powers the dictation feature in macOS — runs entirely on your Mac. You can wrap it in a continuous-listening daemon and have it transcribe everything you say into a target window, no cloud round-trip. Pair it with a local TTS engine running a cloned version of your own voice (the cloning runs on the Mac too) and you have full speech in, full speech out, neither end touching a network.

3. Phone-as-remote. iMessage on a Mac can be driven by AppleScript. That means anything your Mac can do — search, code, browse, compose — can be triggered by a text from your phone. The phone becomes a remote for the more powerful machine, and the more powerful machine handles the heavy lift while you’re somewhere else.

Stack those three together and you have a workflow where:

– You can ask the Mac to do something while you’re nowhere near it.

– You can hold a spoken conversation with it without typing or looking.

– It can produce real work — code, documents, research, video — and deliver it back to wherever you are.

That’s ambient computing. Not Siri. Not Alexa. The full deal.

Why this matters now

Two arguments. The boring one: the bodily cost of screen-and-keyboard computing is real and accumulating. Carpal tunnel, posture damage, eye strain, the chair-and-desk economy that exists to patch over the damage we’re doing to ourselves. We’ve been pretending this is fine for thirty years. It’s not.

The interesting one: ambient computing is what makes a different relationship with the machine possible. When the computer is something you face for eight hours a day, it occupies a specific role in your life — interrupt-driven, attention-stealing, mostly adversarial to whatever else you wanted to be doing. When the computer is something you talk to in passing, hand things off to, and check back on later, it occupies a completely different role. It becomes a colleague rather than a chore.

We’re not going to fully arrive there in 2026. But the building blocks are shipping in 2026, and the people who set them up now will look up in two years and realize their working life feels different.

The catch

For now, all of this requires being on a Mac. Specifically, an Apple Silicon Mac with enough unified memory to run a real model — practically, that means an M2 Max / M3 Max / M4 Pro / M5 Max with 32 GB minimum, 64 GB+ for the bigger models. That’s an expensive piece of hardware.

But it’s a piece of hardware most professionals already own, or could justify. And it’s the only piece you need. There’s no recurring AI subscription. No hosting bill. No phone-home telemetry that compromises the whole privacy story.

The gear that gets you into ambient computing is gear you might already have. You just haven’t connected the pieces yet.

What I’m building toward

The longer arc, for me, is robotics. Specifically a Lego-like modular system where you clip together small parts to build whatever the moment needs — a robot arm, a camera mount, a wheeled base — all driven by the same local AI vision system that runs everywhere else in the stack. That’s a few years out.

In the meantime, I’m shipping the parts of the system that work today. The local-AI server is open source (claude-code-local). The voice loop is open source (NarrateClaude). The browser agent is open source (browser-agent). The phone bridge is open source. The iPhone object-detection app that’s part of the same vision is on the App Store (RealTime AI Cam) for free.

If any of this resonates — if you’ve been quietly tired of being chained to a screen, or you can feel the future being built but haven’t been able to put your finger on what it is — clone something, run it, and tell me what you find. Most of the work ahead is figuring out which pieces fit where, and that’s not work I can do alone.

The era of hunched-over-a-screen is ending. The next era is being built in the open, on commodity hardware, by people who decided to stop waiting for someone else to do it.

— Matt

Part of the Nice Dreamz lineup. If you want this set up inside a firm or practice — private, on-device, no cloud — that’s AirGap AI.

Originally published at Marijuana Union. For premium vaporizers visit iNeedHemp, wholesale at Nice Dreamz, and seeds at Tribe Seed Bank. Explore the 3D cannabis marketplace at The Farmstand.

What Its Actually Like to Code By Voice — With the AI Replying In My Own Cloned Voice

Matt Macosko — Wed, 22 Apr 2026 09:53:21 +0000

The closest analogy I can give for what this feels like is having a quiet co-worker in the room who happens to sound exactly like you. You think out loud. They respond out loud. You both work on the same code. Neither of you is touching a keyboard.

It’s still a little uncanny. But it’s also the most natural way to work I’ve found in twenty-plus years of writing software.

The setup runs entirely on my MacBook. Apple’s on-device speech recognition listens for me. A local language model thinks. A cloned-voice text-to-speech says the response back. Nothing leaves the laptop. Nothing requires a network. The whole loop is on-device, and that turns out to matter for reasons I didn’t expect.

How it actually works

A compiled Swift binary wraps Apple’s SFSpeechRecognizer — the same engine that powers macOS dictation — in a continuous-listening daemon. It transcribes everything I say into the active terminal window where Claude Code is running. End-of-utterance is detected by a stability heuristic: if the recognized text stops changing for about 2.5 seconds, the recognizer treats that sentence as final and submits it.

That submission gets injected into Claude Code via AppleScript, addressed to a specific window by ID so it can’t leak into whatever else is open. Claude Code processes the request against a local language model running on MLX (Apple’s native ML framework). The response comes back as text in the terminal — and a separate launcher pipes that text into a TTS engine running a cloned version of my voice. The reply plays through the speakers. The listener auto-pauses while audio is playing, so the model’s spoken reply never gets picked up as a new prompt. Then it resumes listening for the next thing I say.

End-to-end latency, on a current MacBook, is around two to three seconds. Fast enough to feel like a conversation. Slow enough that you notice it’s a different kind of pacing than typing.

What surprises you the first hour

The first thing that surprised me is how much I already narrate while coding. The interior monologue — “okay let me look at the test, that’s failing because the path is wrong, let me grep for the constant, oh it’s in a different file, fix that here…” — turns out to be most of how I work anyway. Speaking it out loud changed nothing about my reasoning. It just routed it to a different output channel.

The second thing that surprised me is how much faster context-switching gets. When you type, you have to break to compose. When you speak, you can just keep going. “That’s done — now check the function signature in the parent class — yeah okay update the docstring to match — git status — looks good, commit it.” Five tasks, no pause, no posture change.

The third surprise is the physical difference. After half a day of voice-driven work I’m not stiff. My eyes aren’t tired. I haven’t held a clamshell wrist position for hours. There’s a real bodily cost to the way we normally use computers, and removing it feels like removing a weight you didn’t know was there.

Why on-device matters specifically for this

You can build a voice-driven coding setup with cloud APIs. Whisper for speech-in, ElevenLabs for speech-out, GPT or Claude for the brain. Many people do. The result is a tool that works great until your wifi gets weird, your API key hits a rate limit, your monthly bill arrives, or you realize you’ve just sent every word you said in front of your laptop today to three different vendors’ servers.

The on-device version doesn’t have any of those failure modes. It works on a plane. It works in a Faraday cage. It works when the rest of the internet is on fire. The bill is a one-time hardware purchase, not a perpetual subscription. And nothing — no audio, no text, no inference request — ever crosses the network. For me that’s the difference between an interesting demo and a tool I actually use day-to-day.

The cloned voice is a real thing, not a gimmick

The cloned voice is the part everyone reacts to first. When the AI reads its response in your own voice, your nervous system files it under “internal monologue” rather than “external announcement.” It’s a smoother experience than a stranger’s TTS voice and it doesn’t pull your attention the same way.

But it works because the cloning is also on-device. The voice clone trains and runs locally — Pocket TTS in my case, but other local TTS engines slot in if you have a preference. Cloud voice services would mean my own voice (and everything I make it say) is sitting on someone’s server. Not interested.

Where it falls short today

Three real limitations:

1. Domain-specific vocabulary. Apple’s recognizer is excellent at general English, less excellent at obscure software terms, library names, and acronyms. “Refactor the YOLOv8 inference loop” often comes through as “refactor the yellow vate inference loop.” The fix is a custom vocabulary file you can register with the recognizer; that closes most of the gap but takes setup time.

2. Background noise. A quiet office is fine. A coffee shop is workable. A hot tub with the jets running, surprisingly, also fine. A room with kids and a dog is harder. The continuous-listen mode is robust but not magic.

3. Long pauses. If you stop talking to think for 20 seconds, the recognizer will sometimes finalize a partial sentence that wasn’t done yet, and you have to restart it. Workable but a real friction point I’m still iterating on.

None of these are fundamental. All of them get better as the recognition models get better, which they’re doing every macOS release.

What this unlocks for me personally

Coding while pacing the room. Coding while cooking. Coding while in the hot tub. (Yes, really. The mac is on a desk; my voice carries; I check back in by walking up to the screen when something needs visual confirmation.) Holding voice work sessions that last for hours without my body breaking down.

It also lets me work in spaces that aren’t desks. Most of my best thinking happens away from a screen anyway — the keyboard part was always the bottleneck. Removing it doesn’t make me think differently. It makes the time I spend actually capturing the thinking more honest about how that thinking happens.

If you want to try it

The local-AI server is at github.com/nicedreamzapp/claude-code-local. The voice listener and dispatcher are at github.com/nicedreamzapp/NarrateClaude. Both are MIT-licensed, both run entirely on a MacBook with Apple Silicon, and both ship with double-click launchers so the install is closer to “set up an app” than “build a system.”

You will spend an evening getting it tuned to your voice and your vocabulary. After that, it just works. And the working life it produces is, in my experience, qualitatively different from screen-and-keyboard.

— Matt

Part of the Nice Dreamz lineup. If you’re a firm exploring private on-device AI, AirGap AI is the engagement I do for setting this up inside law / medical / accounting practices.

Originally published at Marijuana Union. For premium vaporizers visit iNeedHemp, wholesale at Nice Dreamz, and seeds at Tribe Seed Bank. Explore the 3D cannabis marketplace at The Farmstand.

A Field Guide to Ambient Computing — The Words for the Thing Thats Coming

Matt Macosko — Wed, 22 Apr 2026 09:53:15 +0000

I’ve been building toward something I don’t have a clean name for yet. The pieces — local AI, on-device speech, the phone-as-remote, hands-free voice loops — exist and ship today. The pattern they form, when you put them together, doesn’t have a settled vocabulary. So I’m coining one. Not because I want to invent jargon, but because a thing without a name doesn’t exist for most people, and this thing is going to exist for everyone within a few years.

Here’s the working glossary. Use these terms. Argue with them. Replace them with better ones if you can think of any. The goal is to give shape to a way of working with computers that’s already real but not yet common.

The Rectangle

Noun. The screen. Short for the glowing rectangle of damage. The thing you’re hunched in front of right now. The thing that defines posture, attention, work pace, and back pain for most people who use computers professionally.

“I want to spend less of my day inside the Rectangle.”

The Rectangle is not bad. It’s just been the only option for so long that people forgot it was an option at all rather than the default state of computing. Once you have a working alternative — and you do now — the Rectangle stops being a given. It becomes one of several places work can happen.

Off-Screen Work

Noun. Productive computing done without facing a screen. The opposite of screen work, not the absence of work. Hands-free voice coding is off-screen work. Texting your Mac from the hot tub and getting back a finished research summary is off-screen work. Listening to your AI narrate a long task in your own cloned voice while you walk around your house is off-screen work.

“Half my morning was off-screen. I shipped more than I usually do at a desk.”

Ambient Computing

Noun. Computing that happens around you instead of in front of you. The machine listens, talks back, sees what you point a camera at, and the keyboard becomes optional rather than mandatory. Ambient computing isn’t smart speakers. Smart speakers ask you to talk to a brand. Ambient computing is your own machine, doing your own work, in your own voice, in the room with you.

“I’m building toward ambient computing — a stack you can talk to, hand things off to, and check back on later.”

To Airgap (verb)

Transitive verb. To configure an AI workflow such that it runs entirely on local hardware with no outbound network traffic — making client data, prompts, and responses physically incapable of leaving the machine.

“We airgapped the firm’s drafting workflow last week. Nothing they paste into the AI hits the internet.”

This is the verb form of AirGap AI, the consulting practice I run for firms in regulated industries. It’s also the right word for what you do when you set up your own local-AI stack on a MacBook and turn the wifi off to prove it works. Both of those count.

Hand-Off Computing

Noun. A workflow where you give the computer a task, walk away, and it tells you when it’s done. Distinct from interactive computing, where you sit and wait, and from background computing, which you forget about until it crashes. In hand-off computing the machine knows you walked away, finishes the work, and notifies you back through whatever channel you set up — usually a text to your phone.

“I just hand-off it the data analysis and go make breakfast. It buzzes my phone when the report’s ready.”

The Two-Slab Posture

Noun. The body shape you assume when working with a laptop and a phone simultaneously — head tilted forward, shoulders rounded, both hands pulled in toward the body. The dominant posture of professional computing in 2026, and the source of much of the chronic pain that office workers attribute to “stress.” The Two-Slab Posture is what off-screen work makes optional.

“By 4pm every day I’m locked in the Two-Slab Posture and I can feel it in my neck.”

Backpack Supercomputer

Noun. A current-generation laptop with enough on-device compute to run frontier-class AI models locally. Specifically: an Apple Silicon MacBook Pro with 64+ GB of unified memory, of the M2 / M3 / M4 / M5 Max generation. The phrase emphasizes that this hardware fits in a backpack while delivering performance that would have required a server rack five years ago.

“My M5 Max is a backpack supercomputer. I take it to client offices and it runs a 70-billion-parameter model on the train ride.”

The Ambient Stack

Noun. The minimum set of pieces required to assemble an ambient-computing setup. As of 2026, on Apple hardware:

A local LLM running through an MLX-native server. (claude-code-local.)
A continuous-listen daemon wrapping SFSpeechRecognizer. (NarrateClaude.)
A cloned-voice TTS for spoken responses in the user’s own voice.
A phone bridge so iMessage can drive the Mac. (Custom AppleScript.)
A local browser agent for web tasks. (browser-agent.)

Five components. All open source. All run on hardware you may already own. The entire stack costs $0 in recurring fees once installed.

To Whisper-Code

Verb. To do programming work via voice, with the AI replying in the developer’s own cloned voice. Distinct from voice dictation (which still requires you to be at the screen to read the result). Whisper-coding is an end-to-end conversation about code, in audio, where the developer never has to look at the screen unless they choose to verify something visually.

“I whisper-coded the fix while pacing the kitchen. Saw the diff after lunch and it was right.”

The Cloned-Voice Loop

Noun. A feedback loop where the AI’s spoken responses are rendered in a TTS clone of the user’s own voice. This makes the response feel less like an external announcement and more like internal monologue, which the human nervous system processes more naturally and at lower cognitive load than a stranger’s voice. The loop runs on-device for the same privacy reasons as the rest of the ambient stack.

“After a week with the cloned-voice loop, hearing a stranger TTS feels jarring.”

Hot-Tub Coding

Noun. Sending a coding or research task to your Mac from your phone while not being at the Mac. Originally literal — sending the task while in a hot tub — now a generic term for any phone-driven hand-off computing session. The hallmark of hot-tub coding is that the human is doing something else entirely while the computer is doing the work the human ordered.

“That whole feature was hot-tub coded. I never sat down to write any of it.”

Local-First AI

Adjective phrase. A system architecture in which AI inference defaults to running on the user’s own device, with cloud as a fallback used only when local can’t handle the task — not the other way around. The cultural and technical opposite of cloud-first AI, which has been the default since 2019. Local-first AI is the architecture every privacy-sensitive industry is now going to need, whether they realize it yet or not.

“For NDA work, the only sane architecture is local-first AI.”

A Note On Ownership

These words don’t belong to me. If you find them useful, use them. If you build on the stack and coin a better word for something I’ve named here, I’ll switch to using yours. The point of giving things names is to make them discussable, not to lock down a vocabulary.

But I do want the pattern they describe to take hold. We have, in 2026, the technology to fundamentally change how working with computers feels — physically, mentally, ergonomically, financially. Most people don’t know it yet because the pattern doesn’t have a name they recognize. These are the names I think will help.

If any of this resonates: clone the open-source stack, assemble your own ambient setup, and tell me what you find. The next decade of computing isn’t being decided in any one company’s roadmap. It’s being decided by who shows up and starts using the parts that already exist.

— Matt

Part of the Nice Dreamz lineup. If you’re a firm that wants the ambient stack installed and air-gapped for compliance reasons, AirGap AI is the engagement I do for that.

Originally published at Marijuana Union. For premium vaporizers visit iNeedHemp, wholesale at Nice Dreamz, and seeds at Tribe Seed Bank. Explore the 3D cannabis marketplace at The Farmstand.

Your Medical Practice Is Probably Using Cloud AI on PHI Right Now — Heres the HIPAA Problem Nobody Is Talking About

Matt Macosko — Wed, 22 Apr 2026 09:27:41 +0000

Walk into any small medical practice today and ask the front-desk staff if they’ve ever pasted a chart note into ChatGPT to “rewrite this so the patient understands it” or to “summarize this lab result.” A lot of them will say yes. Some will say no but their browser history says otherwise. A few will look genuinely surprised that anyone’s asking.

Here’s what they’re not thinking about: protected health information (PHI) under HIPAA includes more than the obvious identifiers. It includes anything that, in combination, could identify a patient — symptoms plus visit date, lab values plus condition, even free-text descriptions if specific enough. Once that text leaves the practice’s network and lands in a cloud AI service, the practice has technically engaged that AI vendor as a business associate, and a Business Associate Agreement (BAA) is required. The big AI providers offer BAAs only on enterprise tiers — usually $$$$ a month. Most practices using ChatGPT or Claude on patient data have no BAA in place at all.

That’s a HIPAA breach waiting to be discovered. And it’s already everywhere.

Why this is suddenly a real problem

For years, the assumption was that nobody on staff would use a “ChatGPT” on actual patient data — it’d be obvious that PHI shouldn’t go to a third-party server. That assumption no longer holds. The tools are too useful. Practice managers, MAs, billers, NPs, even physicians are routinely pasting things in: prior-auth letters, patient instructions, summary letters to referring providers, insurance appeal templates, lab interpretations.

Each of those sessions, on the major cloud AI providers, is potentially a HIPAA-reportable event. The practice doesn’t know it. The vendor doesn’t know who the patient is. But under the regulation, the disclosure happened the moment the text crossed the network boundary without a BAA in place.

OCR enforcement actions in the past few years have been heavy on exactly this kind of “we didn’t realize we were using a third-party processor” finding. Penalties for unintentional disclosure under the HIPAA Privacy Rule start at $137 per violation and can reach $68,928 per violation depending on culpability — and “violations” can be counted per record disclosed. A single staff member pasting 30 patient summaries into ChatGPT over a quarter is, by the regulation’s math, 30 violations.

Most practices are not okay if they’re audited tomorrow.

The fix that actually works: on-device AI

The practice doesn’t have to give up AI. It just has to keep it on the practice’s own machines, where there’s no third-party processor relationship.

Modern Apple Silicon Macs — the kind a lot of practices already have at the front desk or in clinician offices — can run open-weight language models locally. The model runs in the Mac’s unified memory using Apple’s MLX framework. Prompts and responses never touch a network connection. There’s no API key, no vendor account, no outbound traffic to log or audit.

For HIPAA purposes, this changes the legal posture entirely. Software running on a covered entity’s own hardware, with no data transmission outside the entity’s secured environment, is not a third-party disclosure. It’s the same legal category as a Word document — local software processing data the practice already has lawful access to.

The HIPAA Security Rule still applies (the Mac itself needs to be physically secured, encrypted at rest, with access controls), but those are the same controls the practice already runs for its EMR workstation. No new vendor risk. No new BAA. No quarterly compliance review of the AI provider’s SOC 2 report.

What it looks like inside a practice

A typical small-practice install:

2-5 MacBooks (front desk, clinician workstations, billing). Most practices already have these.
An open-source MLX server installed on each, running a 31B or 70B language model.
A simple chat interface on the desktop. Looks and feels like ChatGPT. Behaves the same. Just doesn’t phone anywhere.
A one-page HIPAA AI Use Policy documenting that the practice’s AI tools run on-premises with no third-party data processors. This goes in the practice’s compliance binder.
An hour of staff training on what tasks make sense for the local AI vs. what should still go through the EMR.

After install, the practice’s AI usage is HIPAA-clean. Nothing to add to the BAA log. Nothing to disclose to patients. Nothing to argue about in an audit.

The specific wins for a medical practice

Patient instructions in plain language. Convert “post-op care: keep wound site dry x 5 days, rotate dressing q12h, NSAIDs prn” into a paragraph the patient will actually read. Local model, no PHI exposure.
Prior auth letters. Drafting these from chart notes is a huge time sink. Local AI can generate the first draft from the relevant note, with the chart never leaving the practice.
Insurance appeals. Same pattern. The AI sees the denial letter and the relevant clinical history; the practice’s data stays local.
Letters to referring providers. Clean, professional, fast — without sending the patient’s chart to a cloud LLM.
Patient education content customized to the practice (not the same generic handouts every other clinic uses).

None of these are dramatic. All of them are time savers worth tens of hours per month per provider. And every one of them is safe to do with on-device AI in a way that’s genuinely not safe to do with cloud AI.

What the cost actually looks like

A small practice using cloud AI properly (with a BAA-covered enterprise tier) is looking at $40-100 per user per month, plus the legal and compliance overhead of vetting the vendor and adding them to the BAA log. That’s $5,000-15,000+ per year in subscription cost for a 5-person practice, before any compliance staff time.

A one-time on-device install for the same practice runs $8,000 to $15,000 all-in (hardware aside — most practices already have the Macs). After that: zero recurring AI subscription cost. The AI runs on hardware the practice already owns, indefinitely.

The financial argument is real, but it’s secondary to the compliance argument. The compliance argument is: on-device AI is the only AI configuration that doesn’t create a HIPAA business-associate relationship. That’s not a marginal advantage. That’s a categorical difference.

Who should be looking at this now

Solo and small group practices doing primary care, behavioral health, dermatology, OB/GYN, mental health, dentistry — anywhere clinicians are tempted to use AI on chart text.
Therapy and counseling practices where session notes are particularly sensitive and where most cloud AI tools are an obvious non-starter.
Concierge / direct-pay practices where patients explicitly chose the practice for higher privacy expectations than chain medicine offers.
Practices that already had a HIPAA scare — a near-miss, an OCR letter, a malware incident — where the leadership now takes data flow questions seriously.
Any practice in California, New York, Massachusetts, or other states with privacy laws that exceed HIPAA in scope.

If the practice’s leadership doesn’t know exactly what AI tools the staff are currently using on patient text, that’s the answer to “should we look at this.” The fix is not to ban AI (it’ll go underground), it’s to give the practice an AI that doesn’t create a vendor-risk problem.

I do on-device AI installations for small medical and therapy practices — fixed-fee, one week start to finish, including the HIPAA AI Use Policy and staff training. If your practice is quietly accumulating AI usage without a clear compliance posture, this is the cleanest fix on the market.

More detail: AirGap AI — book a 15-minute call from that page and I’ll walk through whether on-device is the right fit for your specific setup.

— Matt Macosko, Nice Dreamz LLC

The open-source software the install is built on is public at github.com/nicedreamzapp/claude-code-local — you or your IT contractor can review exactly what runs on practice hardware.

Originally published at Marijuana Union. For premium vaporizers visit iNeedHemp, wholesale at Nice Dreamz, and seeds at Tribe Seed Bank. Explore the 3D cannabis marketplace at The Farmstand.

DEV Community: Matt Macosko

Eight local AI agents on a Mac mini — and the product I'm building from them

The asset base

The gap that ate me for a month

The market gap, in numbers

The ladder

The three core agents

What's in the AirGap Box

Validation before scale

Honest year-1 range

What I will publish honestly

Links

Why I'm posting this

Why I Quantize Open-Weight Models for Macs — And Why Your Law Firm Should Care

The hobbyist case is easy

The interesting case is law firms

Why open weights specifically

What you can do with this

What this is not

Links

Hermes-4-14B Abliterated, MLX 4-bit — Apple Silicon Just Got Another Real Model

What it is

Why this matters for Mac users

How to run it

Where it slots into the local-first stack

Why I publish these

What's next

Links

504,571 Brain Cells, 4 Labs, One Hypothesis: A Citizen Pass at Parkinson's

Where the idea actually came from

What I actually ran

Why this could actually matter

What I want to be very careful not to claim

Why I am publishing this

I Just Watched One Hacker Catch Up to a Trillion-Dollar Data Center

What I actually did

What the auroras actually looked like

What this means for the cloud AI bill

Three things ds4 does that nobody else has bundled

What I'm doing next

HumanEval on a MacBook — 81.7% pass@1, Wi-Fi off

Why this number matters

Methodology

For context — Qwen3-Coder 480B's official agentic benchmarks

Why the offline part matters

Reproduce it yourself

Pulling 10x My Subscription Value Out of Claude — While Quietly Building the Backup Plan

The honest comparison

Why is Anthropic eating the difference?

The tells it's already tightening

What I built quietly on the side

The honest takeaway

Free AI on a MacBook vs $100-a-Month Claude Code — Hexagon Shootout

The setup — same prompt, three contestants

The results

Three things that surprised me

1. Bigger isn't better when "bigger" is a generalist

2. Claude Code's harness chokes local models

3. Circle-approximation collision is the cheat code

Who should care

How to run it yourself

TL;DR

The Era of Hunched-Over-A-Screen Computing Is Ending — Heres Whats Replacing It

What ambient computing actually looks like

Three pieces that already exist

Why this matters now

The catch

What I’m building toward

What Its Actually Like to Code By Voice — With the AI Replying In My Own Cloned Voice

How it actually works

What surprises you the first hour

Why on-device matters specifically for this

The cloned voice is a real thing, not a gimmick

Where it falls short today

What this unlocks for me personally

If you want to try it

A Field Guide to Ambient Computing — The Words for the Thing Thats Coming

The Rectangle

Off-Screen Work

Ambient Computing

Three things `ds4` does that nobody else has bundled