What is Locals?
Locals is a model server for Macs with Apple silicon, built on Apple's MLX, aimed at coding agents rather than chat. It answers the OpenAI, Anthropic Messages and Ollama APIs on 127.0.0.1:8321, so OpenCode, Claude Code, Cline, Aider, OpenHands and apps written for Ollama can use it without changes. Its main trick is batching: requests from several agents are computed together with GPU kernels written for small batches, where mlx-lm stops getting faster.
Tool calls and JSON are written under a grammar applied on the GPU, so an agent can only call tools it offered and arguments match their schema. Conversations and long system prompts are cached, including on disk across restarts. Commands such as locals code ~/my-project and locals launch claude start the server and connect a client in one step, and locals run splits a task between several agents working in separate copies of a project.
It is made by Generated Computers, written in Python, released under Apache 2.0 and installed with uv tool install locals or a shell script. It needs an M1 or newer and macOS 14. Version 0.2.2 came out on 4 November 2026.
Is Locals worth it?
Locals targets a case Mac model servers handle poorly: several agents asking at once. On an M2 Pro with 16 GB and the default Qwen3.5-4B, the project measures mlx-lm at 87 tokens a second for eight requests at once and Locals at 271, a 3.1x gain; LFM2.5-2.6B and Gemma 4 E4B gain 2.8x. With eight agents, the first word arrives after 1.6 seconds against 41.8 for Ollama, and Locals also beat llama.cpp's 2.1 seconds in the same test.
The benchmarks name the chip, model, versions and command, and the README has a section on where it is not faster. A single request with nothing to reuse runs at mlx-lm's speed, 64 against 61 tokens a second. Long prompts are limited by the GPU's arithmetic, so eight 8,000-token prompts at once give 57 tokens a second. Formats other than standard 4-bit groups of 64 get no gain, and on the M5 Pro the gain shrinks to about 1.5x because MLX already uses its neural accelerators. M1, M3 and M4 chips are not in the main tables.
The agent features matter as much as the speed. Grammar-constrained tool calls remove a common failure of small local models, malformed calls that stall an agent. Cached prompts mean the next turn of a 138,000-token conversation starts after 2.4 seconds. The default model handles about 178,000 tokens on a 16 GB Mac, though reading 170,000 tokens the first time takes about 12 minutes.
On security, the server has no authentication and relies on binding to 127.0.0.1, plus Host and Origin checks so a web page in your browser cannot use it. Its docs note that the Host check switches off if you bind to another address. locals code runs OpenCode directly in your project, with OpenCode's usual permissions, and makes Locals OpenCode's default model until you run locals disconnect opencode. Team runs with locals run are confined to copies of the project.
Against Ollama or LM Studio, Locals gives up GGUF files and Windows and Linux for speed under concurrent load on a Mac. For one person chatting with one model, the difference is small. For a developer running sub-agents or a small agent team on a 16 GB MacBook, it is the larger gain, and the project is young: three releases since 21 October 2026 and 649 stars.
Where it earns its place
A freelance developer on a 16 GB MacBook Pro
Run OpenCode on a client project without sending code to an API
uv tool install locals, then locals code ~/project; the first run downloads a model of about 3 GB. OpenCode's sub-agents share the batch, which is where the 3.1x gain applies; there is no per-token bill.
A small team already using Open WebUI and Raycast with Ollama
Speed up shared local models without changing every app
Quit Ollama and run locals launch --model qwen3.5:4b ollama so Locals answers on Ollama's port with Ollama's model names. Models are downloaded again in MLX format, and going back is locals stop and restarting Ollama.
A back-office developer turning messy text into records
Extract structured fields that always match a JSON schema
locals generate --schema person.json returns JSON that follows the schema field by field, and the same works through the OpenAI API with response_format. Batch many documents at once to use the throughput gain.
Before you commit
- Setup
- curl the install script, or uv tool install --python 3.12 locals, then locals code ~/my-project. Needs an M1 or newer, macOS 14 and ideally 16 GB; on chips other than the M2 Pro and M2 Max it tunes itself in 10 to 20 minutes of idle time.
- Integrations
- OpenAI-compatible /v1 on 127.0.0.1:8321, Anthropic Messages for Claude Code, and the Ollama API; launchers for OpenCode, Claude Code, Cline, Kilo Code, OpenHands, Aider, Hermes Agent and OpenClaw; settings for Roo Code, Continue, Zed and JetBrains.
- Data and privacy
- Runs locally; models download from Hugging Face. No authentication: binds to 127.0.0.1 by default, rejects requests whose Host or Origin is not local, and turns the Host check off when bound to another address. Keeps conversations and system prompts in a cache, including on disk.
- Cost at scale
- The software is free; the cost is the Mac. On an M2 Max with 96 GB, eight requests to a 27B model reach 78 tokens a second against 25 for mlx-lm; Recursive's Flint (40B, 2.5B active) needs 24 GB or more.
- Limits
- One model at a time; MLX models only; no Windows or Linux. Gains come from concurrency and caching: single uncached requests and long prompts run at about mlx-lm's speed.
What’s good
- 3.1x mlx-lm's throughput with eight requests at once on an M2 Pro
- Tool calls and JSON constrained to the schema, so they always parse
- OpenAI, Anthropic and Ollama APIs; one command per agent tool
- Benchmarks published with a list of where it is not faster
What’s not
- Apple silicon and macOS 14 only; MLX models, not GGUF
- Little gain for a single request or long prompts
- No authentication; safety depends on staying on loopback
- Only M2 Pro, M2 Max and M5 Pro well measured; one month old
Best for
Mac developers who run several coding agents or sub-agents against a local model and want them to finish faster.
Locals alternatives
Locals: common questions
- Is Locals worth it?
- The Mac model server to choose when several agents share one small model, with measured gains and an unusually frank list of where it is not faster. We rate it 3.9 out of 5.
- How much does Locals cost?
- Free and open source (Apache 2.0). Each model keeps its own licence.
- What are the downsides of Locals?
- Apple silicon and macOS 14 only; MLX models, not GGUF; little gain for a single request or long prompts; no authentication; safety depends on staying on loopback; only M2 Pro, M2 Max and M5 Pro well measured; one month old.
- Who is Locals best for?
- Mac developers who run several coding agents or sub-agents against a local model and want them to finish faster.
- How much does Locals cost for a team or in production?
- The software is free; the cost is the Mac. On an M2 Max with 96 GB, eight requests to a 27B model reach 78 tokens a second against 25 for mlx-lm; Recursive's Flint (40B, 2.5B active) needs 24 GB or more.
- Is Locals safe for company data?
- Runs locally; models download from Hugging Face. No authentication: binds to 127.0.0.1 by default, rejects requests whose Host or Origin is not local, and turns the Host check off when bound to another address. Keeps conversations and system prompts in a cache, including on disk.
- What are the best Locals alternatives?
- The closest alternatives we have reviewed are Ollama, MLX and llama.cpp.
Answers checked Nov 13, 2026.