Large models run on the Machine in front of you. Once a model is serving, the engine cannot open a network connection — the prompt has nowhere else to go. Hybrid Mind is the second use case: keep that engine and put a cloud API beside it, under one endpoint, with a priority between them — so a model you host and a model you rent answer the same agents, and you can always tell which one did.
MLX checkpoints in the picker, and Hybrid Mind. Version 1.0.9, build 77, is uploaded and on TestFlight internal testing; the App Store version record is prepared and no build is submitted for review yet, so 1.0.8 is still the released version. TestFlight is not the App Store, and this band says so rather than implying otherwise.
Until now every model in the picker was one .gguf. Five catalogue models are also published as MLX checkpoints — a folder with a config.json, safetensors shards and a tokenizer — and the mlx engine reads that format. Where a model exists in both, the row carries a switch: GGUF runs on this app's own engines, MLX runs on mlx-server. The choice is remembered per model.
Each checkpoint is catalogued per file, with the publisher's own byte size and checksum, because a directory has no single artefact to verify. Nothing is fetched that the engine does not read — no model card, no licence text, no helper scripts — and an interrupted download resumes from the file it was missing.
Gemma 4 26B A4B (15.6 GB), Ternary Bonsai 2 27B (8.6 GB), Qwen3.8-27B 4-bit MTP (16.1 GB), Laguna XS 2.1 NVFP4 (21.6 GB) and Qwen3.8-Flash-Next 4-bit MTP (113.2 GB, published by TensorFold).
These are the reference checkpoints the finished MLX.fast optimisation tracks pinned. Two tracks published records — 453.1% over a serial control for Bonsai 2, 111% composite for Qwen3.8-Flash-Next — measured by that competition, on its hardware, against its own control. The winners were the submitted engines, not the models. What this release adds is a verified download and a way to serve the weights those engines were tuned against.
And it does not serve them with a winning engine, which was measured rather than assumed: the Bonsai 2 track's winning tree, at the submission holding that record, decoded 10.0–10.4 tok/s against the stock MLX engine's 30.7–35.3 on the same checkpoint, three repetitions each, greedy, on an M1 Ultra 128 GB. Its advantage is speculative decoding driven by a pinned drafter the serving binary will not load, so what is reachable is the slower target-only path.
“Browse…” now accepts a model folder as well as a .gguf, Spotlight finds MLX checkpoints already on this Mac and lists them as models, and a folder you choose is granted access once and remembered across launches.
One new model. Gemma 4 26B A4B — 26B parameters, 4B active, QAT 4-bit, 15.6 GB. It is catalogued as an MLX checkpoint only; there is no GGUF for it, and it carries an unevaluated badge because no speed figure has been measured for it here.
The app fronts the local engine and a cloud API you configure on its own port, speaking all three request shapes, so Claude Code on /v1/messages, Codex on /v1/responses and opencode-style clients on /v1/chat/completions all get it without being reconfigured. A priority says which side to try first.
Off until you turn it on; it states that prompts will leave before the first enable; the engine keeps its own port, so anything already pointed there stays local-only; every reply is tagged with the side that answered, and both sides are counted. When the provider reports no remaining credit it says so once and goes local-only rather than asking again — turning the cloud back on retries, and will ask again if the account is still unfunded.
The engine itself is untouched and still network-locked: it holds no outbound entitlement, and the cloud call is made by the app, which needs network access for model downloads anyway. That asymmetry is why the engine's guarantee survives the feature.
The local service can compact an agent's fixed preamble before the model prefills it (off by default). Measured on a real captured Claude Code request with 23 tools, tool definitions were 64% of the body and the system prompt only 8% — the opposite of the obvious guess. Compacting tools first removed 77% of the tool definitions and 52% of the whole prefilled context, about 24.7K approximate tokens down to 11.9K, while keeping every tool's name and required parameters: a clipped description makes a tool worse to choose, a missing name makes the call impossible to construct, and those are different kinds of damage.
It sits in the protocol parsers rather than one client's path, so all three shapes shrink — 85%, 87% and 85% on one deliberately bulky tool. What is not claimed is an end-to-end run with each agent: the ratios above come from one captured Claude Code request, and another agent's preamble has a different shape.
The MLX engine is a separate mlx-server binary installed beside the app's other engine files, and macOS does not let the Mac App Store build launch an app outside itself. MLX models therefore run in the Developer-ID build only, and the App Store build says so plainly rather than failing with an engine error. The GGUF version of every model above except Gemma 4 runs in both builds.
Four of the five checkpoints were loaded and served through the app's engine path on an M1 Ultra 128 GB, answering with correct completions, their catalogued checksums checked against the bytes on disk. The fifth, the 113 GB Qwen3.8-Flash-Next pack, was fetched in full and does not load on the bundled engine: it reaches 75.8 GiB of weights and then trips a runtime precondition inside that architecture's embedding layer. Said plainly because the row is in the catalogue.
Served by a third-party MLX binary this app does not ship, the same pack decodes at 26.4 tok/s on this machine (median of three, 628-token prompt, 128 generated), against 43.7 for the GGUF form of the same model on the reference engine. That is a capacity result, not a verdict on the packaging: its per-layer embedding table was paged from SSD rather than resident, and whether its draft head engaged is unconfirmed — the binary logs no acceptance rate.
A decode step of Ternary Bonsai 2 issued 1171 separate GPU dispatches; nine kernel pairs are now fused into one each, taking it to 659, bit-identical — all 248320 logits match as bit patterns. On an M1 Ultra 128 GB, twelve interleaved whole-process runs (six fused, six not) measure +12.9% against this session's own control, and the fused rate, 33.46 tok/s at a 256-token prompt, clears the 32.0 goal this work was aimed at. Still not in build 77 or any shipped build.
Earlier releases are kept in full: 1.0.8, 1.0.7, 1.0.6, 1.0.5, 1.0.4, 1.0.3 and 1.0.2.
Four decisions stand between a model file and a running assistant. The app makes each one explicitly, and tells you which choices your Machine can actually honour — a 594 GB model is offered, flagged, and honestly priced rather than hidden.
One command. It detects the accelerator, fetches only the matching binary, checks it against a published SHA-256, and installs the key:
Without a key it installs and runs the unlicensed path, so you can try it before buying one.
Piping a script into a shell asks you to trust what you cannot read, which is the opposite of everything else on this page. The same install, verifiable:
One key, every binary. The licence carries an expiry and the address it was issued to, and nothing else — there is no per-binary entitlement, so a key bought for one accelerator works on the others as they ship. It is checked offline against a public key compiled into the binary: no network is consulted, so it works on an air-gapped machine, and it stops working the day after it expires without needing to phone home. Keys come from peria.ai, emailed on purchase.
Enforced, not promised. Once the engine has loaded weights and bound its port, it asks the kernel to revoke its own networking — irreversibly, for the life of the process.
The one exception, named rather than buried. A hybrid mode can put a cloud API beside the local engine, and a prompt the cloud side answers does leave this Mac. It is off until you turn it on, it says so before the first time, it runs on a different port from the engine — so anything already pointed at the engine stays local-only — and every reply records which side produced it. The engine itself stays locked either way: it is the app, not the engine, that can reach the network, which is why the engine's guarantee survives the exception.
Check it while it serves:
lsof -i -a -p <pid>
1.0.3 adds one door, and it is locked by default. Serving others binds the LAN instead of loopback — so it needs a key you minted, it is refused without one, and it switches itself off again at the next launch. Nothing you do not turn on this session.
The first use case is everything above: your model, your Machine, nothing leaving. The second is one endpoint over two models — the local engine and a cloud API you choose — with a priority saying which to try first.
Why it is one feature and not two switches: the conversation survives the move. A priority alone gives you a second model. A priority plus a rolling summary plus a cooldown gives you one assistant that keeps working when the cloud rate-limits, runs out of credit, or cannot be reached — it falls back to the Machine and carries on.
It serves whichever protocol your agent speaks, so Claude Code, Codex, opencode and the rest all get it from the same port without being reconfigured.
Off until you turn it on, on a different port from the engine, and every reply records which side produced it. When the cloud runs out of credit it tells you once and goes local-only rather than asking again.
The app writes each agent's config and points it at the local engine.
dsh)newEvery run reports time to first token, prefill and decode rate — beside the engine that produced them and the model actually served.
Two prompts: a short chat, and a ~3000-token passage that measures real prefill.
Rankings are links, not verdicts — 1.0.3 lets you add the leaderboard you trust beside the ones we shipped.
Every download carries its expected SHA-256. A mismatch is refused rather than loaded, and a partial file is reported as incomplete instead of failing later as corruption.
Local Mind is a small amount of new code on top of a great deal of open source. Named because a benchmark is meaningless without saying whose code produced it, and because these projects are the reason any of this runs at all.
The inference engine itself is not open. The kernels it runs are generated by tooling that is, which is the part worth reading.
reference option and used as the correctness oracle our own kernels are checked against.Each carries its own licence, shown in the app before download.