Skip to content

an open-source alternative to the dots, bots and muses of the world, run an office of claude code/codex like agents on your laptop, sandboxes or anywhere, uses your existing subscriptions

docs(cli-agents): local/open-model setup blogs (open-models + Mac-Mini) [ondev-e/f]

Chaitanya Girib15fa42a11fa
diff --git a/blog/src/posts/run-munder-difflin-on-a-mac-mini.md b/blog/src/posts/run-munder-difflin-on-a-mac-mini.md
new file mode 100644
index 00000000..eb809e3a
--- /dev/null
+++ b/blog/src/posts/run-munder-difflin-on-a-mac-mini.md
@@ -0,0 +1,228 @@
+---
+title: "Run Munder Difflin Locally on a Mac Mini"
+description: "A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint."
+date: 2026-06-22
+category: guides
+categoryLabel: Guides
+type: Technical
+draft: false
+primaryKeyword: "run munder difflin on a mac mini"
+secondaryKeywords: ["local llm mac mini", "ollama mac mini", "apple silicon unified memory llm", "offline ai agents mac", "lm studio mac mini agents"]
+tags: ["Guides", "Local-First", "Mac Mini", "Ollama", "LM Studio", "BYOK"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "Can a Mac Mini run a Munder Difflin hive offline?"
+ a: "Yes. An Apple Silicon Mac Mini runs the model locally through Ollama or LM Studio, and Munder Difflin points OpenCode and Crush at that local OpenAI-compatible endpoint (in v0.3.1 pi reaches models through a third-party provider key rather than a local server). The hive's control plane (router, scheduler, mailboxes, audit log) is already local-first, so once the model is local there is no cloud dependency at all."
+ - q: "How much RAM does the Mac Mini need for local AI agents?"
+ a: "It depends on the model size, not the agent count — every worker shares one local model server. As a rule of thumb on Apple Silicon's unified memory: 16GB comfortably runs 7–8B models, 24GB runs up to ~14B, 32GB up to ~32B (tight), and 48–64GB (M4 Pro) runs a 70B-class model quantized to 4-bit. See the RAM-tier table below."
+ - q: "Ollama or LM Studio — which should I use on a Mac Mini?"
+ a: "Either works; both expose an OpenAI-compatible server that Munder Difflin's engines can target. Ollama is a lightweight CLI/daemon (great for headless, always-on hives); LM Studio is a GUI with a model browser and a one-click local server. You can even run both and point different engines at different ports."
+ - q: "Which open-source models run best on each engine?"
+ a: "All three engines — OpenCode, Crush, and pi — select models in `provider/model` form. For the fully-local path, OpenCode and Crush point at a local OpenAI-compatible endpoint, so the same locally-served model works across both; in v0.3.1 pi runs through a third-party provider key instead. For the exact, version-verified model slugs and per-RAM-tier picks, see the open-source model catalog linked below — that's the single source of truth we keep current."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>A <strong>Mac Mini</strong> with Apple
+Silicon can run an entire <strong>Munder Difflin</strong> hive <em>offline</em>. Serve an open-source
+model locally with <strong>Ollama</strong> or <strong>LM Studio</strong>, size the model to your
+<strong>unified memory</strong> (16GB → ~7–8B, 24GB → ~14B, 32GB → ~32B, 48–64GB → 70B-class at 4-bit),
+then point <a href="/blog/why-cli-agents-are-powerful/">OpenCode and Crush</a> at the local endpoint via
+<strong>Settings → AI Engines</strong> (pi uses a third-party provider key in v0.3.1). The hive's control plane is
+<a href="/blog/local-first-ai-agent-orchestration/">already local-first</a>, so nothing leaves the box.</p></div>
+
+It's one thing to run a single local model in a chat window. It's another to put a whole *team* of
+agents to work on your own hardware, with no API bill and no data leaving the room. That's the promise
+of running Munder Difflin on a Mac Mini: the [orchestration is already
+local-first](/blog/local-first-ai-agent-orchestration/) — the message router, scheduler, mailboxes, and
+git audit log are all processes on your machine — so the only remaining cloud dependency is the model
+call itself. Move that local, and the hive is fully offline.
+
+This guide walks the whole setup: picking a Mac Mini tier, understanding how Apple Silicon's unified
+memory bounds what you can run, installing a local model server, and wiring each CLI engine to it.
+
+## Why the Mac Mini is a good hive box
+
+The Mac Mini is the cheapest way into Apple Silicon's **unified memory** architecture, and unified
+memory is exactly what local LLMs want. On a Mac, the CPU, GPU, and Neural Engine all share one pool of
+high-bandwidth RAM — so the model's weights live in the same memory the GPU computes against, with no
+copy across a PCIe bus. A 32GB Mac Mini can hold a model that would need a 32GB *discrete* GPU on a PC,
+at a fraction of the price and power draw. And because the Mini is small, quiet, and sips power, it's a
+natural always-on box for a hive you leave running for hours.
+
+One catch worth knowing up front: **Apple Silicon RAM is soldered to the chip and cannot be upgraded
+after purchase.** Buy the memory you'll want for the largest model you intend to run — it's the one
+spec you can't change later.
+
+## Step 1 — Pick a Mac Mini tier for the model you want to run
+
+Model count doesn't drive your RAM — *model size* does. Every worker in the hive shares one local model
+server, so a ten-agent hive and a two-agent hive on the same model need roughly the same memory. What
+you're really choosing is **how large a model the box can hold.**
+
+A 4-bit-quantized model needs roughly **0.6 GB of memory per billion parameters** for its weights, plus
+headroom for the KV cache (grows with context length), the model server, and macOS itself. macOS also
+caps how much unified memory the GPU may pin — by default around 65–75% — though you can raise that
+ceiling on a dedicated box with `sudo sysctl iogpu.wired_limit_mb=<MB>` when you need to fit a large
+model. A practical rule: **plan for the model to use about two-thirds of your unified memory** and leave
+the rest for context and the OS.
+
+Current Mac Mini lineup and what each tier comfortably runs (4-bit quant):
+
+| Mac Mini | Unified memory | Memory bandwidth | Comfortable model size (Q4) |
+|---|---|---|---|
+| M4 (base) | 16GB | 120 GB/s | ~7–8B (e.g. an 8B-class coder) |
+| M4 | 24GB | 120 GB/s | up to ~14B |
+| M4 | 32GB | 120 GB/s | up to ~32B (tight; short context) |
+| M4 Pro | 48GB | 273 GB/s | ~32B with room, or a 70B at heavy quant |
+| M4 Pro | 64GB | 273 GB/s | 70B-class at 4-bit |
+
+*(Newer Mac Mini chips raise bandwidth and the memory ceiling, but the same "model ≈ two-thirds of
+unified memory" sizing rule carries over — pick the tier by the model size you want.)*
+
+Here's a concrete pick for each tier. Pull these with Ollama (LM Studio carries the same models as
+GGUF/MLX): `ollama pull <tag>`, then reference the model as `local/<tag>` in OpenCode or `ollama/<tag>` in
+Crush (more on that in Step 3).
+
+| Mac Mini RAM | Recommended pick (Ollama tag) | Weights (Q4) | Good for |
+|---|---|---|---|
+| 16GB | `gpt-oss:20b` (tight) — or lighter `qwen3:8b` / `deepseek-r1:8b` | ~14GB / ~5GB | Smallest genuinely capable default; the 8B picks leave more context headroom |
+| 24GB | `qwen3:14b` · `mistral-small:24b` | 9–14GB | Roomy generalist with context to spare |
+| 32GB | `qwen3:30b-a3b` (MoE) · `qwen3-coder:30b` · `deepseek-r1:32b` | ~19–20GB | The sweet spot — fast MoE generalist, coding, or reasoning |
+| 48GB (M4 Pro) | `glm-4.7-flash` (q8) · `mixtral:8x7b` | 26–32GB | Bigger context, plus the only Mac-viable GLM |
+| 64GB (M4 Pro) | `llama3.3:70b` · `deepseek-r1:70b` | ~43GB | A 70B-class generalist or reasoner at 4-bit |
+| 96GB+ (Studio-class) | `gpt-oss:120b` · `llama4:scout` | 65–67GB | Top local models; need ~80GB resident |
+
+These picks are drawn from the model families our open-source model catalog tracks — the single source of
+truth we keep version-current.
+The companion guide, <a href="/blog/run-munder-difflin-on-open-models/">running Munder Difflin on open
+models</a>, pairs each tier with the same picks and adds the third-party-provider route.
+
+<div class="callout"><span class="ic">⚠️</span><p><strong>What a Mac Mini <em>can't</em> run
+locally.</strong> The frontier open-weight flagships — <strong>Kimi K2.x</strong> (~1&nbsp;trillion
+parameters) and <strong>GLM-5.2</strong> (744B) — are server-class: their 4-bit weights run to hundreds of
+gigabytes, far past any Mac Mini. To use those, skip the local server and point an engine at a third-party
+open-source-model provider (OpenRouter, Groq, DeepInfra, and friends) with an API key — covered in the
+<a href="/blog/run-munder-difflin-on-open-models/">open-models guide</a>. For a genuinely local GLM,
+<code>glm-4.7-flash</code> (~30B) is the Mac-friendly member of the family.</p></div>
+
+## Step 2 — Install a local model server
+
+You have two solid options. Both expose an **OpenAI-compatible HTTP endpoint**, which is exactly what
+Munder Difflin's engines target.
+
+### Option A — Ollama (lightweight, headless-friendly)
+
+```bash
+# Install (Homebrew) and start the daemon
+brew install ollama
+ollama serve # runs the API on http://localhost:11434
+
+# Pull a model (pick the tag for your RAM tier — see Step 1)
+ollama pull gpt-oss:20b # 16GB-friendly default; swap for your tier's tag
+```
+
+Ollama's OpenAI-compatible API is served at **`http://localhost:11434/v1`**. It runs as a background
+daemon, which makes it the natural choice for an always-on hive box.
+
+### Option B — LM Studio (GUI, model browser, one-click server)
+
+Download LM Studio from [lmstudio.ai](https://lmstudio.ai), search and download a model in its UI, then
+start the **Local Server** (the "Developer" / server tab). LM Studio serves an OpenAI-compatible API at
+**`http://localhost:1234/v1`**.
+
+<div class="callout"><span class="ic">💡</span><p>You can run <em>both</em> — Ollama on :11434 and LM
+Studio on :1234 — and point different engines at different ports if you want to compare models side by
+side across your workers.</p></div>
+
+## Step 3 — Wire each CLI engine to the local endpoint
+
+Munder Difflin runs each agent on a pluggable [CLI engine](/blog/why-cli-agents-are-powerful/). All three engines select models in **`provider/model`** form, but for the fully-local path it's **two** —
+OpenCode and Crush — that wire a local OpenAI-compatible endpoint in v0.3.1, so the same locally-served
+model works across both. (pi reaches models through a third-party provider key in this release — see its
+note below.) The fastest path
+is **Settings → AI Engines**: set the per-engine base URL to your local server and pick the model; the
+harness writes the right per-agent config for you. Here's what that maps to under the hood for each
+engine.
+
+### Crush
+
+Crush reads a JSON config. Define the local server as an **`openai-compat`** provider (this keeps it on
+the OpenAI wire, which is what the harness proxy expects — don't use Crush's native `ollama`/`lmstudio`
+discovery types for the hive path):
+
+```json
+{
+ "providers": {
+ "ollama": {
+ "name": "Ollama",
+ "type": "openai-compat",
+ "base_url": "http://localhost:11434/v1",
+ "api_key": "ollama",
+ "models": [
+ { "name": "gpt-oss 20B", "id": "gpt-oss:20b", "context_window": 131072, "default_max_tokens": 8192 }
+ ]
+ }
+ }
+}
+```
+
+Then select the model as `ollama/gpt-oss:20b` (swap in the tag for your RAM tier from Step 1). For LM
+Studio, use `base_url: "http://localhost:1234/v1"`, `api_key: "lm-studio"`, and a `lmstudio` provider key,
+then select `lmstudio/<model-id>`.
+
+### OpenCode
+
+OpenCode reaches a local model through a custom OpenAI-compatible provider (the `@ai-sdk/openai-compatible`
+adapter with `options.baseURL`). In Munder Difflin, set the OpenCode base URL in Settings → AI Engines to
+your local server and choose the model in `provider/model` form; the harness supplies the engine config.
+
+### pi
+
+A heads-up specific to **v0.3.1**: pi's local-endpoint field is **reserved.** This release wires a local
+base URL for OpenCode and Crush only — it does not yet write a local provider into pi's `models.json` — so
+the fully-offline path today runs on **OpenCode or Crush.** To put pi to work in this release, point it at
+a third-party open-source-model provider instead of a local server: set a provider key in **Settings → AI
+Engines** (e.g. an OpenRouter or Groq key) and pick an open-model slug such as
+`openrouter/openai/gpt-oss-120b` or `groq/llama-3.3-70b-versatile`. pi joins the local path once its
+local-endpoint field ships; until then, build your offline hive on OpenCode and Crush.
+
+<div class="callout"><span class="ic">📋</span><p><strong>The same local model, three prefixes.</strong>
+Once a model is served locally, each engine names it slightly differently: OpenCode as
+<code>local/&lt;tag&gt;</code>, Crush as <code>ollama/&lt;tag&gt;</code>. For example, gpt-oss 20B is
+<code>local/gpt-oss:20b</code> in OpenCode and <code>ollama/gpt-oss:20b</code> in Crush. (In v0.3.1, pi
+points at a third-party <code>provider/model</code> slug instead, per the note above.) The exact slugs for
+every tier live in the <a href="/blog/run-munder-difflin-on-open-models/">open-source model catalog</a>,
+kept in one place so they don't drift.</p></div>
+
+## Step 4 — Run the hive offline
+
+With a model served locally and the engines pointed at it, the rest of Munder Difflin is already
+local-first. Spin up your workers from the [Agent Gallery or Add Agent](/blog/how-to-install-and-use-munder-difflin/),
+give the hive a goal, and let it run. The [message router](/blog/atomic-file-mailboxes-for-agents/) moves
+work between agents through file mailboxes, the scheduler fires tasks on local timers, and git records
+the audit trail — none of it touches a network. Pull the Ethernet cable and the hive keeps working.
+
+A few operational notes for an offline Mac Mini hive:
+
+- **One model, many workers.** Every agent shares the local server, so concurrency is bounded by the
+ Mac Mini's compute, not by per-agent memory. Watch tokens/sec under load and keep contexts trim on the
+ 16/24GB tiers.
+- **Keep it awake.** A headless always-on hive wants the Mini to not sleep — set Energy settings to
+ prevent sleep (or `caffeinate` the session) so the router and scheduler keep ticking.
+- **Quantization is your lever.** If a model won't fit, drop to a heavier quant before dropping a tier —
+ 4-bit is the usual sweet spot for coder models on these boxes.
+- **Fully offline means OpenCode or Crush.** In v0.3.1 those are the two engines that wire a local base
+ URL, so a hive built on them runs with the cable pulled. pi currently reaches models through a
+ third-party provider key (its local field is reserved), so pi workers need a network — mix engines
+ accordingly if total isolation is the goal.
+
+## Where to go next
+
+- The companion guide, [run Munder Difflin on open models](/blog/run-munder-difflin-on-open-models/),
+ covers running fully local *or* through a third-party open-source provider, and pairs each RAM tier
+ with a concrete model pick.
+- For the *why* behind keeping it all on your machine, see [why local-first matters for AI
+ agents](/blog/why-local-first-matters-for-ai-agents/).
+- New to the app? Start with [how to install and use Munder
+ Difflin](/blog/how-to-install-and-use-munder-difflin/).
diff --git a/blog/src/posts/run-munder-difflin-on-open-models.md b/blog/src/posts/run-munder-difflin-on-open-models.md
new file mode 100644
index 00000000..741b6a92
--- /dev/null
+++ b/blog/src/posts/run-munder-difflin-on-open-models.md
@@ -0,0 +1,141 @@
+---
+title: "Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider"
+description: "Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines."
+date: 2026-06-22
+category: guides
+categoryLabel: Guides
+type: Technical
+primaryKeyword: "run ai agents on open source models"
+secondaryKeywords: ["local llm coding agent", "ollama coding agent", "openrouter coding agent", "gpt-oss", "byok open models", "opencode crush pi"]
+tags: ["Guides", "Local-First", "Open Source", "CLI Agents", "Tutorial"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "Can Munder Difflin run entirely on open-source models?"
+ a: "Yes. As of v0.3.1 the OpenCode, Crush, and pi engines all support bring-your-own-key (BYOK) and local models. You can run every agent — workers and the god orchestrator — on open-weight models like gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, or Kimi, either fully local on your own hardware or through a third-party OSS provider with your own API key."
+ - q: "What's the difference between running local and using a third-party provider?"
+ a: "Local (Ollama, LM Studio, vLLM) runs the weights on your own machine — fully private, no per-token bill, but bounded by your RAM and GPU. A third-party OSS provider (OpenRouter, Groq, Together, Fireworks, DeepInfra) hosts the same open weights on their hardware and you pay per token with your own key — no local hardware limit, so you can reach the 100B–1T-parameter frontier models a laptop can't hold."
+ - q: "Which open model should I pick for the god orchestrator?"
+ a: "The god seat does the reasoning and long-context coordination, so give it a strong model: locally, gpt-oss-120b or Llama 3.3 70B on a 64–96 GB machine; via a provider, DeepSeek-V4-Flash, GLM-4.6, or Kimi-K2.6 on OpenRouter. Small local models (8B and under) are fine for routine workers but underpowered for orchestration."
+ - q: "Do I need a different model id for each engine?"
+ a: "No — the upstream model id is the same. All three engines use a provider/model slug; only the provider prefix and how the key or base-URL is wired differ. For local models, OpenCode uses local/<id> while Crush and pi use ollama/<id>."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin v0.3.1 runs entirely on open models.</strong> The three new engines — <strong>OpenCode</strong>, <strong>Crush</strong>, and <strong>pi</strong> — all support bring-your-own-key and local LLMs, for workers <em>and</em> the god orchestrator. Two routes: <strong>fully local</strong> (Ollama / LM Studio / vLLM on your own machine — private, no per-token bill, bounded by RAM) or a <strong>third-party OSS provider</strong> (OpenRouter, Groq, Together, Fireworks, DeepInfra — their hardware, your key, reaching frontier 100B–1T models a laptop can't hold). Every engine uses a <code>provider/model</code> slug; you set keys and local base-URLs in <strong>Settings → AI Engines</strong>, then pick the model in the Add-Agent modal.</p></div>
+
+Munder Difflin started as a harness for the closed frontier CLIs — Claude Code, Codex, Antigravity. Useful, but it tied your agent floor to a handful of vendors and their pricing. **v0.3.1 breaks that open.** It adds three engines that were built, from the start, to point at *any* model: [OpenCode](https://opencode.ai), [Crush](https://charm.land), and [pi](https://pi.dev). All three speak the open-weight ecosystem — and that means you can run an entire office of agents on models whose weights are public.
+
+There are two honest ways to do that, and they trade off differently. This guide walks both, then shows the exact wiring for each engine. (For the why-bother, see [why local-first matters for AI agents](/blog/why-local-first-matters-for-ai-agents/) and [why CLI agents are so powerful](/blog/why-cli-agents-are-powerful/).)
+
+## Two routes: your hardware, or someone else's
+
+"Open source models" is one phrase covering two very different setups. Pick by what you're optimizing for.
+
+| | Fully local | Third-party OSS provider |
+|---|---|---|
+| **Runs on** | Your machine (Ollama, LM Studio, vLLM) | Their GPUs (OpenRouter, Groq, Together, Fireworks, DeepInfra, Novita) |
+| **Cost** | Electricity. No per-token bill. | Per-token, billed to your own key. |
+| **Privacy** | Total — code never leaves the box. | Prompts transit a third party. |
+| **Ceiling** | Bounded by RAM/VRAM (≈7B–70B realistic on a Mac). | The whole frontier — 235B, 480B, even 1T-parameter models. |
+| **Setup** | Pull a model + point the engine at `localhost`. | Paste one API key. |
+| **Best for** | Private work, 24/7 unattended, fixed cost. | Frontier quality, zero local hardware, bursty use. |
+
+You don't have to choose globally — Munder Difflin sets the engine and model *per agent*. A common pattern: a strong provider-hosted model in the god seat for orchestration, and cheap local workers for the routine majority. That's exactly the [capability-routing](/blog/do-more-with-less-model-routing/) idea, now with open weights on both ends.
+
+## How the three engines name a model
+
+One thing to internalize before any wiring: **all three engines use the same `provider/model` slug form.** The *model* part is just the upstream's id (e.g. `openai/gpt-oss-120b`, `qwen3:30b-a3b`). The *provider* prefix resolves one of two ways:
+
+- **A built-in provider** the engine already knows — supply the matching API-key env var and you're done. OpenCode (via the AI-SDK / models.dev registry), Crush, and pi each ship a list of recognized providers: `openrouter`, `openai`, `anthropic`, `groq`, `deepseek`, `mistral`, and the local ones.
+- **A custom OpenAI-compatible provider** you define once (a `base_url` + key block) for any host that isn't built in — Together, Fireworks, DeepInfra, Novita, Z.ai, Moonshot. Then the slug is `<your-name>/<model-id>`.
+
+The *local* route differs slightly by engine — same id, different prefix and wiring:
+
+| Engine | How v0.3.1 wires local | Local slug |
+|---|---|---|
+| **OpenCode** | Injects a custom provider named `local` (OpenAI-compatible) with your base-URL. | `local/<id>` |
+| **Crush** | Writes a provider block (`type: ollama / lmstudio / openai-compat`) into the agent's config. | `ollama/<id>` |
+| **pi** | Not wired in v0.3.1 — the local base-URL field is **reserved** (file-based `models.json` is a fast-follow). Run open models on pi via a third-party provider key for now (see Path B). | — |
+
+Default endpoints are the usual ones: Ollama `http://localhost:11434/v1`, LM Studio `http://127.0.0.1:1234/v1`, vLLM whatever you exposed (often `:8000/v1`). You set these in the app — no shell exports required.
+
+## Path A — fully local (Ollama / LM Studio / vLLM)
+
+Three steps: pull a model, tell Munder Difflin where it lives, pick it for an agent.
+
+**1. Pull a model.** With [Ollama](https://ollama.com) installed, grab one sized to your RAM:
+
+```bash
+ollama pull gpt-oss:20b # 14 GB — runs on a 16 GB Mac, the safe default
+ollama pull qwen3:30b-a3b # 19 GB — fast MoE generalist, 32 GB
+ollama pull deepseek-r1:32b # 20 GB — strong reasoning, 32 GB
+ollama serve # exposes the OpenAI-compatible API on :11434
+```
+
+(LM Studio works the same way — load the model in the app and it serves on `:1234`. vLLM and llama.cpp expose their own OpenAI-compatible endpoint.)
+
+**2. Point the engine at it.** Open **Settings → AI Engines**, find the engine you'll use (**OpenCode** or **Crush**), and set its **local base-URL** field to your endpoint — e.g. `http://localhost:11434/v1` for Ollama. This is the per-CLI local field v0.3.1 added; the harness uses it to inject the right provider config when it spawns the agent. No API key needed for local. (pi's local base-URL field is **reserved** in v0.3.1 — the harness doesn't yet write it a `models.json` — so to run open models on pi today, use a third-party provider key via Path B below.)
+
+**3. Hire an agent on that model.** In the **Add-Agent** modal, choose the engine, then pick the local model. The picker offers the open-model quick-picks; the slug it sends is `local/gpt-oss:20b` on OpenCode, or `ollama/gpt-oss:20b` on Crush (keep the colon in the tag). That agent now runs fully on your hardware.
+
+Which local model? Match it to your machine. These picks are from the project's open-model catalog, by RAM tier:
+
+| Model | Ollama tag | Min RAM | Good for |
+|---|---|---|---|
+| gpt-oss 20B | `gpt-oss:20b` | 16 GB | Smallest capable default |
+| Mistral Small 24B | `mistral-small:24b` | 16–32 GB | Lightweight generalist |
+| Qwen3 30B-A3B (MoE) | `qwen3:30b-a3b` | 32 GB | Fast MoE generalist |
+| Qwen3-Coder 30B | `qwen3-coder:30b` | 32 GB | Coding |
+| DeepSeek-R1 32B | `deepseek-r1:32b` | 32 GB | Reasoning |
+| GLM-4.7-Flash | `glm-4.7-flash` | 32 GB | The only Mac-viable GLM |
+| Llama 3.3 70B | `llama3.3:70b` | 64 GB | Bigger generalist |
+| gpt-oss 120B | `gpt-oss:120b` | 96 GB | Top local (Studio-class) |
+
+A note on what *won't* fit: the headline frontier open models — DeepSeek-V4 (1.6T / 284B), Kimi K2.6 (~1T), GLM-5.2 (744B), Qwen3-235B — are server-class. The Ollama tags exist, but no consumer Mac holds them. For those, you want Path B. (Choosing a local model by RAM is the whole subject of the companion [Mac Mini setup guide](/blog/run-munder-difflin-on-a-mac-mini/).)
+
+## Path B — a third-party OSS provider (BYOK)
+
+Same open weights, hosted on someone else's GPUs, billed to your own key. This is how you reach the big models, and it's a two-field setup.
+
+**1. Get a key.** Sign up with a provider and copy an API key. [OpenRouter](https://openrouter.ai) is the easiest start — one key, the widest catalog (it fronts most of the others). [Groq](https://groq.com) is the fastest for the models it carries. Together, Fireworks, and DeepInfra host the heavyweights.
+
+**2. Paste it into the app.** In **Settings → AI Engines**, enter the key in the matching field. Keys are stored **write-only through the broker** — the renderer can set a key but never read it back; only the main process injects it as the right env var (`OPENROUTER_API_KEY`, `GROQ_API_KEY`, …) when an agent spawns, and only for the provider that agent actually uses. Nothing lands in plaintext config.
+
+**3. Pick a model.** In Add-Agent, select the engine and a provider-hosted model. The slug carries the provider prefix — e.g. `openrouter/deepseek/deepseek-v4-flash` or `groq/openai/gpt-oss-120b`. The recommended BYOK quick-picks:
+
+| Model | Route | Slug | Key env |
+|---|---|---|---|
+| gpt-oss 120B (fastest) | Groq | `groq/openai/gpt-oss-120b` | `GROQ_API_KEY` |
+| Llama 3.3 70B | Groq | `groq/llama-3.3-70b-versatile` | `GROQ_API_KEY` |
+| DeepSeek-V4-Flash | OpenRouter | `openrouter/deepseek/deepseek-v4-flash` | `OPENROUTER_API_KEY` |
+| GLM-4.6 | OpenRouter | `openrouter/z-ai/glm-4.6` | `OPENROUTER_API_KEY` |
+| Kimi K2.6 | OpenRouter | `openrouter/moonshotai/kimi-k2.6` | `OPENROUTER_API_KEY` |
+| Qwen3-Coder 480B | OpenRouter | `openrouter/qwen/qwen3-coder` | `OPENROUTER_API_KEY` |
+| gpt-oss 120B | OpenRouter | `openrouter/openai/gpt-oss-120b` | `OPENROUTER_API_KEY` |
+
+Prefer a model maker's own API? Those work too: DeepSeek (`deepseek/deepseek-v4-flash`, `DEEPSEEK_API_KEY`), Mistral (`mistral/...`, `MISTRAL_API_KEY`), Z.ai for GLM, Moonshot for Kimi. A couple of moving targets worth knowing as of mid-2026: DeepSeek's `deepseek-chat` / `deepseek-reasoner` aliases retire on 2026-07-24 (wire `deepseek-v4-flash` directly), and Groq is sunsetting Llama 4 — so on Groq stick to gpt-oss and `llama-3.3-70b-versatile`. The full slug-by-slug table, with citations and verify-live caveats, lives in the project's open-model catalog (the single source of truth this post and the Mac Mini guide both cite).
+
+## Per-engine cheat-sheet
+
+You rarely touch these directly — the AI Engines panel writes them — but here's what each engine does under the hood, so the model field makes sense.
+
+**OpenCode** is OpenAI-SDK native and knows most providers out of the box. BYOK is just the env var; local is a custom provider named `local`. Slugs: `openrouter/openai/gpt-oss-120b`, `local/qwen3:30b-a3b`.
+
+**Crush** reads BYOK env vars for its built-in providers and uses a written config block for anything custom or local. For local Ollama it's literally:
+
+```json
+{ "providers": { "ollama": { "type": "ollama", "base_url": "http://localhost:11434/v1" } } }
+```
+
+then select `ollama/qwen3:30b-a3b`. For a host like Together, it's an `openai-compat` block with that provider's `base_url` and your key.
+
+**pi** (the Pi Coding Agent) ships 15+ built-in providers, so BYOK is just the provider key. Slugs look like `groq/llama-3.3-70b-versatile` or `openrouter/qwen/qwen3-coder`. Its local base-URL field is **reserved** in v0.3.1 — Munder Difflin doesn't yet write pi a `models.json` — so for now run open models on pi through a third-party provider key rather than a local endpoint; local-via-base-URL is a fast-follow.
+
+All three are god-eligible in v0.3.1, so you can put an open model in the orchestrator seat, not just the workers. For the god seat, give it a strong one — `gpt-oss:120b` or `llama3.3:70b` locally (64–96 GB), or a frontier provider model like `openrouter/deepseek/deepseek-v4-flash`. Sub-8B models are great workers but thin for orchestration.
+
+## The bottom line
+
+Open weights turn Munder Difflin from "a harness for three vendors' CLIs" into "a harness for the whole open ecosystem." Run it **fully local** when privacy and fixed cost matter and your RAM can hold the model; run it on a **third-party provider** when you want frontier quality or no local hardware at all — and mix the two across your floor, agent by agent. The setup is two fields in **Settings → AI Engines** and a pick in Add-Agent; the open-model slugs are curated in the project catalog so you don't have to guess.
+
+That's the promise kept: a virtual office of CLI agents on your own computer, now running on models whose weights anyone can read. [Download Munder Difflin](https://munderdiffl.in/#install) — it's free, open source, and local-first. Then point your favorite open model at it. (On a Mac and want the hardware-by-RAM walkthrough? Read the [Mac Mini setup guide](/blog/run-munder-difflin-on-a-mac-mini/).)