Local Code Review: A Free AI Agent That Lives on Your Mac

On October 28, 2026, the team behind Draw Things — the Apple-device image and video generation app with a genuinely loyal following — released something different into the world: Local Code, a private AI agent for the Mac that runs frontier-class models entirely on your own machine. No account. No API keys. No cloud. Two days later it is still one of the strangest value propositions in AI software: a free, open-source agent whose top model asks for 376 gigabytes of your SSD and 64 gigabytes of your RAM.

I spent the week reading the release announcement, the pricing page, and the source code README so you do not have to. Here is what Local Code actually is, what it costs once you read the fine print, and the three things the announcement glosses over.

Quick answer

• What it is: A free, open-source Mac app (mostly Swift) that runs an AI agent locally on Apple Silicon — with Python 3.14, Node.js 24, a shell, LibreOffice, FFmpeg, a WebKit browser, and the Draw Things CLI built into the app.
• What it costs: $0 for local use. Optional cloud access is bring-your-own API keys at no markup, or prepaid Cloud Credit top-ups starting at $9.99. There is no subscription.
• What you need: At least 16 GB of RAM for the smallest model, 64 GB or more for the flagship. Downloads run from 9.6 GB to 376 GB.
• The catch: It is open source under GPL-3.0, but the Mac app cannot actually be built from source yet — the patched build tool it needs has not been published. And every speed and benchmark figure comes from the developers themselves.

What Local Code actually is

Local Code comes from the Draw Things team, and it shows. Draw Things earned its reputation by squeezing serious local image and video generation out of Apple Silicon, and Local Code is the same instinct applied to agents: one app download that bundles an LLM inference engine for Apple Silicon, a coding harness, and an agent runtime.

The runtime is unusually rich for a free app. Compiled into the download: an OSH shell (grep, sed, awk, find, diff, rg, jq, zip, curl, git, ssh), Python 3.14 with NumPy, pandas, Matplotlib, Pillow, lxml, openpyxl, python-docx, python-pptx and pypdf, Node.js 24, Lean 4 plus Z3, LibreOffice (driven through an office command), FFmpeg with html2video and hyperframes for motion graphics, a real WebKit browser for pages that need JavaScript or a sign-in, and the Draw Things CLI for local image and video generation.

Then you pick one of three quantized models from a built-in selector, and the whole thing works offline:

• Qwen 3.8 27B — the small one, for 16 GB+ Macs
• DeepSeek 4 Flash 0731 — a 304B-parameter text model, for 48 GB+ Macs
• DeepSeek 4.1 Flash 1017 — a 763B-parameter model, for 64 GB+ Macs

The timeline matters for context: a public beta began around September 12 (per MacRumors' launch coverage), and on October 28, 2026 the app was released to the world and fully open-sourced at the same time. The download is currently a DMG from getlocalcode.app; a Mac App Store release is listed as "coming soon," and that is all the company has said about it.

Setup: what it asks for and what it does not

Setup is the least demanding part of this review. Download the DMG, open the app, and during setup it suggests a model based on your Mac's memory — no sign-in, no API keys, no external tools to install, no MCP servers to configure. If your machine changes its mind later, you can switch models without reinstalling.

The memory suggestions, straight from the project's README:

• Under 32 GB of RAM: Qwen 3.8 27B, 2-bit S quantization
• 32 GB or more: Qwen 3.8 27B, 4-bit S
• 48 GB or more: DeepSeek 4 Flash 0731
• 64 GB or more: DeepSeek 4.1 Flash 1017

The clever bit is SSD streaming. Models larger than your RAM still run: the app keeps part of a model on your SSD and pages it in as needed, with the in-memory expert weights capped at your Mac's memory minus 32 GB (or 72% of free memory at load). So the big models run on smaller Macs — just slower. The release notes say the 763B-parameter flagship runs at usable speeds with as little as 36 GiB of resident memory, delivering roughly 350 tokens per second of prompt processing and 18 per second of generation on a machine with 64 GiB of RAM.

The model menu and the real hardware bar

Here is the honest hardware picture, with the project's README as the authority (it disagrees with the marketing page on one figure, which I flag below):

Two flags on that table. First, the getlocalcode.app pricing page lists Qwen's download as "10–21 GB," while the README's own table says 9.6/21.3/29.2 GB depending on quantization. The README wins; the site's shorthand is loose. Second, the quantization the project uses is tuned to take advantage of the M5 Ultra's Neural Accelerators — this is an app built for Apple's newest silicon first.

On speed: the project's own charts claim DeepSeek 4.1 Flash 1017 (2-bit S) hits 346 prefill / 18.7 decode tokens per second on an M5 Max with 128 GB, and 4,600 / 58.9 on an M5 Ultra with 256 GB at 8K context — prefilling faster than MLX-Serve v26.10.3 and oMLX on the same hardware. That is their hardware, their harness, their chart. There are no independent measurements of these figures anywhere yet, and the release post's headline claim — that the flagship "surpasses GPT-5.6 Sol on many benchmarks and in real-world use cases" — rests on the developers' own reruns against officially reported results, with "no regression in intelligence" after quantization. Treat all of it as the vendor's account until someone else runs the harness.

What it can actually do

The release announcement reads like a demo reel, and it is worth quoting the plain-language version: generate images, videos, and sophisticated infographics with precise charts locally (Python plus the draw-things-cli); create slides and explainer videos with motion graphics; write Python or JavaScript or review code; visit websites, log in with your credentials, make appointments; connect to Photos, Messages, Mail, Notes, and Calendar; update spreadsheets, read Word documents, edit PowerPoint.

Under the hood, the app ships a set of built-in skills that explain where that list comes from:

• office — create, read, and edit Word, PowerPoint, and Excel files, plus PDF export
• answers-charts — Matplotlib charts inline in answers
• hyperframes — motion graphics generated from HTML
• use-draw-things-cli — local image and video generation
• use-web-browse-cli — drives the built-in browser, including pages that need a sign-in
• deploy-static-site-with-wrangler — publishes work to a temporary public URL
• use-mcp-with-mcporter — connects external MCP servers if you want them
• check_lean-and-lean-tools — Lean 4 and Z3 for formal verification work
• skill-creator and introduce-local-code — onboarding and skill authoring

The app layer has the touches you would expect from a team that has shipped consumer software: tasks and threads are durable (saved, resumable after you close the app), an interrupted reply can continue where it stopped, you can steer the agent mid-task by messaging it, and long-term context lives in a cache on disk rather than evaporating between sessions.

The sandbox is the actual product

Here is the part of Local Code that deserves more attention than the model menu. The app runs inside Apple's App Sandbox with the Hardened Runtime. It cannot read your whole disk. It cannot launch other apps. It cannot touch the cloud unless you explicitly choose that. It can only operate in the folders you share with it.

The personal-data handling is thoughtfully asymmetrical: with your permission it can read from Mail, Messages, and Notes — but those commands are read-only even after you grant access — while Calendar and Photos allow changes. That is a real privacy design, not a privacy page. Compare it with the standing warning on self-hosted agents like OpenClaw, whose own README tells users to treat inbound messages as untrusted input — Local Code's answer to the same threat is confinement rather than caution. (We covered OpenClaw's WhatsApp-controlled agent earlier this week.)

The price math

The headline is simple: local use costs $0. The pricing page puts it plainly — per token, bring your own API keys at no markup; cloud credit top-ups from $9.99 for hosted models; no subscription anywhere.

The fine print is where the review lives:

• Local tier ($0): the app, the inference engine, and your choice of the three downloadable models. No account, no payment, full functionality offline. The real cost here is your hardware and your bandwidth — that 376 GB download is not a metaphor.
• Cloud Compute ($9.99 top-ups): prepaid credit for hosted models — 32 models are listed. But there is no published per-model price table, and nothing is stated about per-token or per-image rates, so you cannot work out what $9.99 actually buys until you spend it. That is the one genuine pricing hole in the product.
• BYO keys (no markup): ChatGPT, Claude, OpenRouter, or any OpenAI-compatible endpoint. Choose a cloud model and your prompts and relevant files go to that provider — the private-local story ends the moment you flip that switch, which is worth knowing before you flip it.
• Teams ("Let's talk"): setup help, custom skills, on-prem deployment — quote-based, no self-serve price published.

No subscription exists at any tier. For a category where the standard pitch is $20 a month per seat, "free locally, pay only for cloud you actually use" is a pricing model with real teeth — as long as you already own the Mac.

Local Code vs the other private agents

(Rival rows reflect our earlier coverage — including the Perplexity Computer local-mode how-to — not fresh verification this week. Local Code's row is verified against the project's own pricing page and README as of October 30.)

Pros

• Local use is genuinely free with no account — download the app, download a model, run it. No trial, no card, no catch in the billing flow.
• Everything runs offline once the model is on disk.
• A real sandbox architecture — App Sandbox plus Hardened Runtime, no full-disk access, read-only Notes/Mail/Messages. A stronger privacy answer than most agents ship with.
• An unusually rich built-in toolchain: Python 3.14, Node 24, Lean 4/Z3, LibreOffice, FFmpeg, a WebKit browser, and the Draw Things CLI, all compiled in.
• Setup auto-matches a model to your RAM, and SSD streaming means the big models still run on smaller Macs.
• Open source under GPL-3.0, from a team with a shipped track record optimizing for Apple Silicon.

Cons

• The top model needs a 376 GB download and realistically 64 GB or more of RAM — effectively gated to high-end Macs.
• Mac only at launch. No Windows or Linux version announced; the iPhone and iPad builds mentioned in the repo tagline have no download yet.
• The Mac app cannot be built from source yet: it is a Mac Catalyst build needing a patched version of Bazel that has not been published (per independent coverage from ithinkdiff). "Fully open source" is the code being public, not the build being reproducible — a legitimate asterisk.
• All speed and benchmark claims are self-run by the vendor. No independent measurements exist.
• No published per-token cloud pricing — you cannot calculate what a $9.99 top-up buys.
• 48 GitHub stars, 2 forks, 0 releases, created October 21, synced from a private development repo. There is no community momentum yet.
• GPL-3.0 copyleft may matter to commercial users who want to build on it.

The honest catches

Three things deserve to be said plainly, because the announcement does not say them.

One: "open source" is not "reproducible" yet. The code is public under GPL-3.0 at github.com/drawthingsai/local-code-community, and that counts. But the Mac app is a Catalyst build that requires a patched Bazel the team has not published, so nobody outside Draw Things can build it from source right now. The iPhone/iPad version builds with Bazel and Xcode once you add your own provisioning profile, and a LocalCodeCLI runs on Mac without signing. Open is a spectrum; Local Code is at the "source readable" end of it for now.

Two: the benchmarks are a press release about itself. "Surpasses GPT-5.6 Sol on many benchmarks," "no regression in intelligence" after quantization, prefilling faster than MLX-Serve and oMLX — all of these are the developers' own reruns on their own hardware, with no independent replication anywhere. The honest version of the claim is: Draw Things quantized a 763B model into a 376 GB package that runs at usable speeds on a Mac, and says it kept its intelligence. That is impressive on its own. The superlatives need a second lab.

Three: the cloud pricing page has a hole. "$9.99 top-ups" with no per-model rate table and no stated per-token prices means the cloud tier is priced like a gift card for a store with no price tags. Fine if you stay local; opaque if you do not.

FAQ

Is Local Code really free?

Yes for local use — download the app, download a model, run it: $0, no account. Cloud access costs extra, either through your own API keys at no markup or prepaid Cloud Credit top-ups starting at $9.99. There is no subscription at any tier.

What Mac do I need?

At minimum 16 GB of RAM for Qwen 3.8 27B (about a 9.6–29 GB download depending on quantization). 32 GB or more gets you better Qwen quantizations, 48 GB or more unlocks DeepSeek 4 Flash (89.4 GB), and 64 GB or more unlocks DeepSeek 4.1 Flash 1017 (376 GB). SSD streaming means the big models still run on smaller Macs — just slower.

Can it see all my files?

No — that is the point of the design. The agent runs inside Apple's App Sandbox, can only touch folders you share with it, cannot launch other apps, and cannot use the cloud unless you choose to. Its Notes, Mail, and Messages commands are read-only even after you grant access.

How do I set it up?

Download the DMG from getlocalcode.app (a Mac App Store release is announced but has no date), open it, and during setup the app suggests a model based on your Mac's memory. No sign-in, no API keys, no external tools to install — and it works offline from there.

Is it really open source?

The code is public under GPL-3.0 at github.com/drawthingsai/local-code-community. The catch: as of launch week, the Mac app needs an unpublished patched version of Bazel to build, so it is not yet fully buildable from source — a detail confirmed by independent coverage, not the announcement.

Key takeaways

• Local Code is a free, open-source AI agent for Mac that runs frontier-scale models entirely on your own device — no account, no cloud, no subscription.
• The sandbox architecture is the real story: App Sandbox confinement, no full-disk access, and read-only personal-data commands make it one of the most privacy-serious agents shipping right now.
• The hardware bar is the price of that privacy: 16 GB of RAM minimum, 64 GB+ and a 376 GB download for the flagship model.
• Cloud access is prepaid credit from $9.99 with no published per-model rates, and Teams pricing is quote-only.
• The two asterisks are the unbuildable source tree and the self-run benchmarks — fix those, and this is one of the most interesting free agents of the year.

As of October 31, 2026, Local Code is a genuine artifact of the local-AI moment: a free, sandboxed agent that asks for your disk and your RAM instead of your data. Whether the build caveat and the vendor-run benchmarks get fixed before the Mac App Store listing arrives is the thing to watch — that is when most people will actually meet it.