Local Code, from the team behind Draw Things, is an open source AI agent for Apple Silicon Macs that downloads a model onto your own GPU and does real work with real tools while nothing leaves the machine. This piece covers its sandbox, its three local models and what they demand from your Mac, the work it claims it can do, its pricing, and who should run it instead of a cloud agent.
Every cloud agent asks for the same trade. Hand over your prompts, your files, and often your whole drive, and in return a model in a distant data centre does the work. For a lot of people that trade is fine. For anyone whose files are the point, client work, private notes, code that has not shipped, the trade is the problem.
Local Code refuses the trade outright. It is a free app for Apple Silicon Macs from the team behind Draw Things, the image generation app with a long record of making big models run well on Apple hardware. You download a model from a selector inside the app, the model runs on your own GPU, and the tools run inside a sandbox on your own machine. The cloud stays off unless you turn it on yourself.
Local Code
Official siteA private AI agent that runs models locally and does real work with built in tools. Primary use case: agent work on files you do not want leaving your machine.
Key features: a built in model selector with three local models sized to your memory; tools that run inside App Sandbox with Hardened Runtime; Python, Node.js and shell access for the agent; a built in browser; connections to Photos, Messages, Mail, Notes and Calendar with your permission; SSD streaming so a model larger than your memory can still run by loading parts from the drive as needed.
Advantages: no account, no sign in and no API key are needed to start, per the maker; it works offline once a model is downloaded; the whole app is open source, so the privacy claims can be read in the code. Limitations: Mac only, and Apple Silicon only; the two larger models demand serious disk space and serious memory; local speed and quality depend entirely on the Mac you own.
Runs here. Stays here.
The flow on the product site is four steps. You ask, the model runs on your GPU, the tools run in the sandbox, and the work lands in your files. With a local model selected, the site states the position plainly: cloud model off, nothing sent.
The offline claim is just as blunt. Turn the WiFi off and it still works, because there is nothing remote in the loop. That is a structural fact about local inference, not a policy promise, and it is why this category keeps growing: a policy can change with a terms update, while an app with no server in the path has nothing to update.
The sandbox is half the product
An agent that can run shell commands is an agent that can do damage, so the walls matter as much as the model. Local Code runs its tools inside App Sandbox with Hardened Runtime, the same containment Apple builds for App Store software.
The site lists what that means in practice. The agent can use the folders you share with it and can run Python, Node.js and shell inside that boundary. It cannot read your whole disk, cannot launch other apps, and cannot use the cloud unless you choose a cloud model.
That folder rule is the right default. Cloud agents tend to ask for broad access up front and sort out the consequences later. Local Code starts with nothing and gets only the folders you hand it, and because the app is open source on GitHub under the drawthingsai account, anyone can check whether the code matches the claim.
Sized to your Mac
Three local models ship in the selector, and the honest headline is that they scale hard. The maker quantizes each model into a package sized for Apple hardware, and the site lists minimum and recommended memory for each one.
| Model | Minimum memory | Recommended memory | Disk space |
|---|---|---|---|
| Qwen 3.8 27B | 16 GB | 32 GB | 10 to 21 GB |
| DeepSeek 4 Flash | 32 GB | 64 GB | 89 GB |
| DeepSeek 4.1 Flash 1017 | 32 GB | 96 GB | 376 GB |
Local model packages, disk space in GB
Package sizes from the Local Code site and the maker release post. The Qwen bar uses the 10 GB base package; the site lists 10 to 21 GB depending on the download.
The release post adds the shape behind those numbers. Qwen 3.8 27B is a 27B parameter model in a 10 GiB package, suited to Macs with 16 GiB or more of memory. DeepSeek 4 Flash 0731 is a 304B parameter model in an 89 GiB package, and DeepSeek 4.1 Flash 1017 is a 763B parameter model in a 376 GiB package.
SSD streaming is how the big end of that table stays reachable. Part of the model stays on your SSD and loads as needed, so a model larger than your memory can still run on a smaller Mac. The maker claims the largest model can run at usable speeds with as little as 36 GiB of resident memory, at about 350 tokens per second for prompt processing and about 18 tokens per second for generation. Treat those speeds and the maker benchmark claims for these builds as claims: they are the vendor numbers, published by the team selling the idea, and no independent test has crossed this desk yet.
What it does once it is in there
This is an agent, not a chat box, and the task list in the release post is broad. It can generate images, videos and infographics with built in Python and the draw-things-cli tool, and it can build slides and explainer videos with motion graphics.
It can write Python or JavaScript and review code. It can update spreadsheets, read Word documents and edit PowerPoint files. A built in browser lets it visit a site, log in and complete a task such as booking an appointment, in the maker example.
With your permission it connects to Photos, Messages, Mail, Notes and Calendar. The maker says it can summarize what it finds there and, where supported, edit and reorganize it. MacRumors, covering the launch on October 30, adds the boundary that matters: reading Mail, Messages and Notes and changing Calendar and Photos happen only with the user permission, inside the limits the sandbox sets.
The cloud is there if you want it
Local is the pitch, not a prison. The app also offers cloud compute with 32 models, plus ChatGPT, Claude, OpenRouter and any OpenAI compatible endpoint, per the product site.
The pricing is simple enough to print in full. On device use costs $0 per token. Bring your own API keys and the maker charges no markup on them. Hosted cloud access runs on prepaid credit, with top ups from $9.99 and no subscription. A Teams tier exists for setup, custom skills and on premises work, priced by conversation rather than by a published rate.
That structure is worth naming because it is rare. There is no monthly rent for the local product at all. The maker makes money when you choose the cloud, and the choice stays yours each time, which is the same shape as the privacy model: local by default, cloud by decision.
Which should you choose
Choose Local Code if your files are the reason you hesitate. Legal drafts, client material, private journals, unreleased code: if the reason you avoid cloud agents is where the data goes, an agent with no server in the path answers the question at the root.
Choose it if you own a strong Mac and resent renting compute back. A Mac with 32 GB or more of memory already holds serious inference hardware. Local Code puts it to work for $0 per token, with bigger models as your memory allows.
Choose it if you want to inspect what you run. The app is fully open source. For a tool that touches Mail, Messages and your folders, the ability to read the code, or to have someone you trust read it, is a feature no closed agent can match.
Look elsewhere if you are not on Apple Silicon. There is no Windows or Linux version in anything the maker has published, and Intel Macs are outside the pitch. Look elsewhere, too, if your Mac has 16 GB of memory and you need flagship class answers: the physics of local models will not bend, and a cloud agent will serve you better than a small model struggling at home.
Final thoughts
Most agent launches argue about intelligence. This one argues about location, and location turns out to be the argument with consequences. A model on your own GPU, tools inside a sandbox you control, folders granted one at a time, and a price of zero on your own hardware add up to a different kind of trust: trust you can verify in the code and in the network silence.
The tradeoffs are physical and plain. You pay in disk space, memory and patience instead of in rent and exposure, and the biggest models are reserved for the biggest Macs. For the reader with the hardware and the files worth protecting, that is a trade worth taking, and Local Code is the cleanest version of it yet shipped for the Mac.
Full disclosure on method: this is a desk review built from the maker site, the maker release post and launch coverage, not a test on our own Mac. The specs, prices and limits above are the published ones, and the speed and benchmark figures are labelled as maker claims where they appear.
Sources
- Product site, models, sandbox, cloud options and pricing: getlocalcode.app
- Maker release post, task list, model packages and speed claims: Local Code by Draw Things
- Source code: drawthingsai/local-code-community on GitHub
- Launch coverage and permission boundaries: MacRumors, October 30, 2026
- Site graphic: Local Code, from getlocalcode.app
END OF TRANSMISSION
Stay curious. Question everything.
