Local Code

Local Code is a private AI agent for Mac, iPad and iPhone, written mostly in Swift. It puts three things in one app: an LLM inference engine for Apple Silicon, a coding harness tuned to each model, and an agent runtime with Python, Node.js, a shell and other familiar tools built in. With these, the agent can work through whole tasks on files you choose, such as analyzing data, charting it, writing documents and slide decks, or building software.

With an on-device quasi-frontier model, such as DeepSeek 4.1 Flash 1017, inference runs on your device and works offline. You can also pick a cloud model from Anthropic, OpenAI, OpenRouter or an OpenAI-compatible server. When you do, your prompts, file contents and tool output go to that provider. Either way, the agent's tools run inside the app's sandbox and can reach only the folders you allow.

Download Local Code from getlocalcode.app.

This repository contains the source code of the app and its command-line tools, along with the libraries and vendored dependencies they are built from.

An Agent That Does Real Work

An agent that does real work needs more than an inference engine, a harness and a model. It also needs what people expect from well-made software:

• Durable tasks and threads: tasks and chat threads are saved, so you can close the app and pick them up later.
• Resumable generation: an interrupted reply, reasoning included, continues where it stopped instead of starting over.
• Steering: you can send a message at any time, even while the agent is working, to change its course.
• Long-term context cache: the model's context is saved to disk, including images and the recurrent state that some models keep, so a long conversation isn't read again from the start.

The engine and the model still matter, and the rest of this section covers them: the models, the sandbox the agent works in, and how fast and how accurately the models run.

Models

Local Code downloads its own quantized checkpoints of each model:

The DeepSeek 4.1 Flash 1017 sizes include a 203 GB engram file, which both of its quantizations share.

The DeepSeek models are mixtures of experts, and they are larger than the memory of most Macs. For example, the DeepSeek 4.1 Flash 1017 (2-bit S) checkpoint is about 173 GB. Local Code keeps as many of the most used experts in memory as there is room for, and streams the rest from disk. It also leaves room for the other apps you run. The experts kept in memory never take more than the Mac's memory minus 32 GB, or more than 72% of the memory that is free when the model loads. So these models run on Macs with less memory than the checkpoint, run faster the more memory there is, and leave the rest of the Mac usable.

During setup, Local Code suggests a model based on the device's memory:

• under 32 GB: Qwen 3.8 27B (2-bit S)
• 32 GB and up: Qwen 3.8 27B (4-bit S)
• 48 GB and up: DeepSeek 4 Flash 0731
• 64 GB and up: DeepSeek 4.1 Flash 1017

You can switch to any model later.

The In-App Sandbox

Local Code doesn't run the agent's commands as separate programs on your computer. The shell, the language runtimes and the command-line tools are compiled into the app and run in its own process, inside Apple's App Sandbox. On a Mac, the Hardened Runtime also protects the app's code. The agent has no full-disk access, and it can't launch other programs on your computer, so it can't run native programs that aren't built into the app.

Each project is a folder inside a workspace that you choose. The agent starts in the project folder and can read and write anywhere in the workspace, plus the app's temporary folder. Packages and caches that the agent installs for a project stay in that project's folder. Commands that use the network, such as web search, curl and ssh, connect out when the agent runs them.

The sandbox includes:

• Shell: OSH from Oils, with common Unix commands such as grep, sed, awk, find, diff, rg, jq, zip, curl, git and ssh.
• Python 3.14: NumPy, pandas, Matplotlib, Pillow, lxml, openpyxl, python-docx, python-pptx and pypdf, and pip for more.
• Node.js 24: npm and npx.
• Lean 4 and Z3: to check proofs and solve constraint problems. Lean can also install Mathlib.
• Documents and media: LibreOffice, through the office command, to convert and render Word, Excel, PowerPoint and PDF files. Also FFmpeg, plus html2video and hyperframes to make videos from HTML.
• Web: web search, and a WebKit browser that the agent can drive to test pages or to use sites that need JavaScript or a sign-in.
• Images and video: the Draw Things CLI, to generate images and videos.
• Personal data: calendar to read and edit events, and photos to find, import, edit and organize photos and videos. On a Mac, notes, mail and imessage also read Notes, Mail and Messages, but they can't change or send anything. Each command works only after you grant access.

Built-in skills show the agent how to use these tools for common work:

You can add your own skills to a project's .agents/skills folder.

Performance on Macs

Speeds are in tokens per second, given as prefill / decode. Each column starts with that much context already in use. On top of it, Local Code prefills one more full chunk, and separately decodes 128 tokens. A chunk is the most Local Code prefills at once on that Mac: 4,096 tokens on the M5 Max, and 8,192 on the M5 Ultra.

M5 Max, 128 GB

On the M5 Max, the DeepSeek 4.1 Flash 1017 readings set Weights Streaming to 56 GiB (--weights-streaming 56 in the CLI). DeepSeek 4 Flash 0731 keeps all of its weights in memory.

M5 Ultra, 256 GB

On the M5 Ultra, both DeepSeek readings are a second pass in the same session, without the 20-second cool-down before each prefill. For DeepSeek 4.1 Flash 1017, its engram entries are also already in memory.

This chart compares DeepSeek 4.1 Flash 1017 prefill speed on the same M5 Ultra in Local Code, in MLX-Serve v26.10.3 with the iQ-MLX 3.0bpw checkpoint, and in oMLX 0.7.2 with the oQ2.5e checkpoint. Each reading times only the prefill of an 8,192-token chunk on top of the given amount of context. The Local Code readings come from the same runs as the table above, and the MLX-Serve and oMLX readings, both with CED on, are medians of three runs. The label above each Local Code point is how much faster it is than the faster of MLX-Serve and oMLX at that context length.

Speeds are in tokens per second.