Local Coding Agents That Actually Work on Apple Silicon

Pointing a coding agent at a local model is easy. Getting the tool calls, streaming, and multi-step edits to actually land is the hard part — and it quietly breaks as the agents ship new versions. So we test it, every release, on the real binaries. Here's what passes.

Wiring a coding agent to a local model is a two-line change: point it at http://localhost:8000 instead of a cloud endpoint. The two lines are easy. What's hard — and what quietly decides whether the agent feels smart or brain-dead — is everything underneath: does the tool call round-trip? Does streaming render token by token? Does a multi-step edit-and-test loop actually terminate? And critically: does it still work after the agent ships a new version next week?

That last question is why a "works with X" badge isn't worth much on its own. Agents like Claude Code and Codex ship new builds constantly, and each one can change the wire shape just enough to break an integration that passed a month ago. So instead of claiming compatibility once and moving on, we re-verify the agents that matter against the current client binary every release — running the real claude, codex, aider, and hermes processes through actual coding tasks on a real model.

Here's the state as of July 2026, on Apple Silicon.

The four agents we verify end-to-end every release

These are the Tier-1 agents — one guardian per API wire, re-verified on the current binary each release:

Each of the three API wires a modern coding agent might speak has a Tier-1 guardian: Anthropic's messages API (Claude Code), OpenAI's newer responses API (Codex), and classic chat-completions (Aider and Hermes). That last wire is the busiest, so it gets two very different guardians — Aider for reach (it's one of the most-installed coding CLIs), and Hermes for depth (it injects 60+ tools every turn, which is the hardest possible stress test for local tool-calling).

What "verified" actually means

Plenty of projects will tell you a tool "works." Here's the specific thing we check, because it's the part that breaks.

We boot a real rapid-mlx serve with a strong 8-bit model (qwen3.6-35b-8bit), point the actual agent binary at it, and give it a real coding task in a throwaway git repo:

A passing run means the agent read the file, ran the test (a real shell tool call), saw the failure, edited the source, re-ran the test, saw it pass, and terminated cleanly. Every Tier-1 agent above did exactly that — the classic off-by-one in a factorial loop, fixed and re-verified by the agent itself, against a local model:

 def factorial(n):
     result = 1
-    for i in range(1, n):
+    for i in range(1, n + 1):
         result *= i
     return result

No hand-holding, no manual retries. The tool loop, the streaming, the stop-reason mapping, and the error handling (unknown model → a clean 404, not a 500 retry-storm) all held up on the current binaries: claude 2.1.211, codex 0.145.0, aider 0.86.2, hermes 0.9.0.

Why an 8-bit model and not a 4-bit one? Because at 4-bit, a weak reply is ambiguous — you can't tell whether the model fumbled or the integration did. A strong model makes any failure attributable to the wire, which is the only thing an integration test should be measuring.

Two-minute setup

The whole thing is one install and one server:

# 1. Install (Apple Silicon)
curl -fsSL https://rapidmlx.com/install.sh | bash

# 2. Start a local OpenAI/Anthropic-compatible server
rapid-mlx serve qwen3.6-35b-8bit

# 3. Point your agent at it — e.g. Claude Code:
rapid-mlx launch claude-code

rapid-mlx launch claude-code patches Claude Code's config to route at localhost — no manual env vars. For the OpenAI-wire agents, rapid-mlx agents codex --setup (or aider, hermes) writes the right config for you. Each agent has a full walkthrough: Claude Code, Codex CLI, Aider, and the Hermes guide.

Once it's running, an all-day agent session costs exactly nothing, and your code never leaves the Mac.

Why these four — and what about Cursor and the rest?

We support 11 agent CLIs plus 3 Python frameworks in total, all wire-verified against real weights every release. The four above are Tier-1 because they get the deepest guarantee: a real end-to-end run on the current binary. The other seven — OpenCode, Qwen Code, OpenHands, Kilo Code, GitHub Copilot, Factory Droid, and Moonshot Kimi Code — are Tier-2: verified in the integration matrix and configured on demand.

One honest note on Cursor: its IDE chat and composer point at a local server just fine (Settings → Models → OpenAI Base URL), and that's worth doing. But Cursor's background agent runs through Cursor's own backend, which can't be redirected to a custom endpoint — so we can't give it the same headless, every-release guarantee a CLI gets. That's a limit of Cursor's architecture, not the model, and we'd rather say so than paper over it. Full details in the Cursor guide.

Coming from Ollama? The migration guide maps the commands one-to-one.

The point

A local coding agent is only useful if it behaves like the cloud one you're used to — tools fire, edits land, the loop ends. That's a moving target, because the agents keep shipping. The four Tier-1 agents here cleared a real edit-and-fix task on current binaries as of July 2026, and we'll re-run it every release. If you want the full per-agent, per-model breakdown — including the documented XFAILs and why they happen — it's all in the integration matrix.