The April 2026 story no AI recap wrote down: MCP arrived on the Mac as a consumer settings panel, not a dotfile
The April 2026 coverage of new open source AI work is dominated by four stories: Llama 4 Scout, Qwen 3 72B, Codestral 2, and OpenAI Codex Labs. In the same calendar window, one MIT-licensed Mac app did something quieter but more consequential for people who are not developers. It shipped a signed, notarized build with the Model Context Protocol wired into a settings panel. Five servers are hardcoded as built-ins. The sixth slot onward is a ~/.fazm/mcp-servers.json file a non-developer can ignore forever, and a power user can diff against Claude Code's config.
What every other April 2026 recap agrees on
If you read three end-of-month recaps for open source AI in April 2026, the headline list is the same. Meta shipped Llama 4 Scout on April 2 as an open-weights checkpoint with a mixture-of-experts backbone. Alibaba shipped Qwen 3 72B on April 5 with a permissive license and strong multilingual benchmarks. Mistral shipped Codestral 2 on April 8 under Apache 2.0. OpenAI announced Codex Labs on April 21 with a GSI partner roster of Accenture, Capgemini, Cognizant, Infosys, PwC, and TCS. Hugging Face trending turned over a few times. Ollama cut engine releases. vLLM posted notes.
That is the story told from the model and infrastructure side. Told from the consumer application side, the month has a different center of gravity. A user who does not run inference at home, does not write Python, and does not edit their shell rc file is not affected by any of those releases for another six months. Meanwhile, between April 16 and April 20, 2026, something did change for that user, and nobody wrote it down.
The anchor, in one line of TypeScript
At line 1266 of acp-bridge/src/index.ts in the public Fazm repo, a single constant lists exactly which MCP servers the app hardcodes as built-ins. Everything in the April 2026 story flows from this line.
That set is the product's spine. Every server it ships, the user gets for free on first install. Every server not in the set, the user adds via ~/.fazm/mcp-servers.json or the settings sheet. The question of which side of the line a server sits on is answered by grep.
“Format mirrors Claude Code's mcpServers. For sixteen months, that format was confined to developer tools. v2.4.0 of Fazm moved it into a settings panel that runs inside a signed Mac app without requiring the user to open Terminal.”
Comment at acp-bridge/src/index.ts:1103, reworded
The five built-ins, what each one actually does
A reader who only knows MCP from dotfile configs may expect a built-in to mean a Python library reference or an npm package name. Inside the Fazm DMG, each built-in is a concrete binary or script shipped in the app bundle. Their roles do not overlap.
fazm_tools
Node stdio process that connects back to the app over a Unix domain socket (FAZM_BRIDGE_PIPE env var). Exposes Fazm's internal tools: memory search, file indexing reads, browser-profile queries, execute_sql against the app's local SQLite. The only server that can reach the app's own data.
playwright
@playwright/mcp, pinned in package.json. Invoked with --output-mode file --image-responses omit --output-dir /tmp/playwright-mcp so snapshots go to disk instead of the LLM context window.
macos-use
Native macOS binary bundled in the DMG. Drives any Mac app through the accessibility tree. This is the server that makes the agent work outside the browser.
Native controller for the WhatsApp Catalyst app via accessibility APIs. Loaded only if whatsappMcpBinary exists at runtime, so older installs degrade gracefully.
google-workspace
Python MCP server with PYTHONHOME pointed at a bundled .venv under the app bundle. Credentials resolve to ~/google_workspace_mcp/ so app-bundle read-onliness never blocks OAuth.
The config file, in 20 lines of JSON
A power user adding Linear, GitHub, and a Postgres MCP server to their Mac is three entries in a file they can write by hand. The file does not need to exist; if it does not, the built-ins ship alone. If it does, every enabled server is loaded on bridge startup and emitted to the settings panel with builtin: false.
Servers with enabled: false are skipped at startup and greyed out in the settings list. Servers with a missing command are logged and skipped. The loader is 37 lines total, and it is the entire bridge-side parse-and-append step.
How the config file turns into running processes
The path from a JSON entry to a child process is short and has no magic. A Node bridge reads the file on bridge startup, merges entries with the five built-ins, and hands the combined list to the Claude Agent Protocol SDK. The SDK spawns one child per server, wires stdin/stdout, and exposes tools to the model.
~/.fazm/mcp-servers.json to running servers in v2.4.0
Before v2.4.0 and after, from the user's seat
MCP existed for the Fazm agent before April 16 (the five built-ins were already loaded), but the user had no say in which servers ran or how to add their own. The release shipped two things at once: the loader, and the settings surface to reason about it.
What adding a new MCP server looked like, pre and post April 20
No user-visible way to add an MCP server. The five built-ins were hardcoded in acp-bridge/src/index.ts and nothing else connected. A user who wanted Linear, GitHub, or Postgres in the agent could not add them without forking the repo, rebuilding, and resigning a DMG. That path requires an Apple Developer account and the Swift toolchain. The practical answer for most users was no.
- Only five servers, ever, per install
- Forking the repo was the only extension path
- Rebuild step required Apple Developer account
- Settings panel had no MCP section at all
The 96-hour timeline, commit by commit
Every commit below is public in github.com/mediar-ai/fazm. Times are Pacific, matching the author date on each commit.
April 16 to April 20, 2026
Thu Apr 16 17:56:47 PT, commit 2152e6a3
Add support for custom MCP servers via ~/.fazm/mcp-servers.json. +37 lines in acp-bridge/src/index.ts. Introduces the loader that reads the user config file, validates each entry, and appends to the servers array passed to the ACP SDK.
Thu Apr 16 17:58:47 PT, commit 9840b05f
Add MCPServerManager to manage MCP server configurations. +114 lines, new file Desktop/Sources/MCPServerManager.swift. ObservableObject singleton that owns the @Published servers array, loads/saves the JSON, and exposes add/remove/toggle methods.
Thu Apr 16 17:59:57 PT, commit 6ca21852
Add MCPServerEditSheet view for MCP server configuration. +209 lines, new file Desktop/Sources/MainWindow/Pages/MCPServerEditSheet.swift. SwiftUI form sheet for adding and editing a server. Fixed to 500px high via commit 30661578 four minutes later.
Thu Apr 16 18:01:38 PT, commit 8cb97bd3
Add MCP Servers section to advanced settings. The Settings page gains its new child section. At this point the feature is wired end-to-end but not yet visible in the sidebar search.
Thu Apr 16 18:04:19 PT, commit 5dfbb255
Fix homeDir reference to homedir() for user MCP config path. Corrects the path resolver after a rename. Small but proves the feature was exercised against a real filesystem before being merged.
Fri Apr 17 12:42:31 PT, commit 261785e0
Add emitMcpServers to broadcast MCP servers and builtin status. Introduces the mcp_servers_available message type used to tell the Swift UI which servers are active and whether each one is built-in or user-added.
Fri Apr 17 12:43:46 PT, commit 2858771b
Add support for mcp_servers_available messages in ACPBridge. The Swift side gains the receive-and-route case for the new message.
Fri Apr 17 12:44:10 PT, commit 83c143a7
Add ActiveServer model and tracking to MCPServerManager. Introduces the ActiveServer struct (name, command, builtin) and the @Published activeServers array that the settings UI binds against. This is where the Built-in versus Custom visual split gets its data.
Fri Apr 17 12:45:03 PT, commit 8c5a7b03
Add built-in and custom MCP server sections to settings. +65 lines in SettingsPage.swift. The Settings UI is now two grouped lists with a per-row enabled toggle on the custom side.
Fri Apr 17 13:06:15 PT, commit a3bb8fac
Fix command property resolution for URL-based MCP servers. Handles the URL-style server shape that the ACP SDK supports alongside command-based stdio servers.
Sat Apr 18 16:16:00 PT, commit 5a1d5a7a
Update @agentclientprotocol/claude-agent-acp to ^0.29.2. The SDK version that the MCP feature depends on in production.
Mon Apr 20 10:41:10 PT, commit dfe79ee5
Add v2.4.0 changelog entry. The headline line reads: Added custom MCP server support via ~/.fazm/mcp-servers.json with Settings UI to add, edit, and toggle servers. The signed DMG went out to users on the same day.
What this actually is, in four numbers
The whole feature is 360 lines of new code, end to end. Everything else was already in place: the ACP bridge, the settings page scaffolding, the SwiftUI binding pattern, the signed-and-notarized build pipeline. v2.4.0 is the release where those pieces lined up to make MCP a consumer-grade surface.
The five built-ins, orbiting the bridge
This is what buildMcpServers() returns for a default install, with no user config file in place.
How this compares to every other MCP client shipping in April 2026
There are more MCP clients than there are months since the protocol launched. A reader who knows the space will want to see where v2.4.0 lands. The short version: it is the first signed, notarized consumer Mac app with a form-based MCP picker and a configurable file format that matches the developer convention.
| Feature | Other April 2026 MCP clients | Fazm v2.4.0 |
|---|---|---|
| Audience | Developers on any OS, installed via npm, pip, or brew | Consumer macOS users, signed DMG, drag to Applications |
| How to add a server | Edit a JSON or TOML dotfile by hand, restart client | Settings, Add, fill form, save; or edit ~/.fazm/mcp-servers.json |
| Built-in servers | Usually zero or one, shipped as npm packages you configure yourself | Five, hardcoded at acp-bridge/src/index.ts:1266 |
| File format | Varies: claude_desktop_config.json, cursor's mcp.json, cline's JSON | mcpServers object, matches Claude Code's convention |
| Toggling a server without deleting it | Comment out the entry and reload | enabled: boolean in JSON; toggle in settings UI |
| Distribution | Terminal install or developer-mode app | One signed and notarized .dmg file, MIT source public |
| Visibility of active servers | Grep the logs, or trust the config | mcp_servers_available emits builtin: true/false per server |
Comparison is against MCP clients as shipped in April 2026. Claude Desktop supports MCP but as of this writing exposes it through a Edit Config button that opens a text file; that counts as JSON editing, not a form.
The rest of the April 2026 open source AI landscape, in one strip
For context, these are the stories you will find in every other April 2026 recap. The Fazm v2.4.0 MCP picker is the one missing from them.
What the 37-line loader actually does, step by step
The loader is the bridge between the user's file and the ACP SDK's server list. It is short enough to audit in one sitting. Every behavior below is named in the commit diff; nothing is inferred.
acp-bridge/src/index.ts, lines 1102 to 1137
- Resolves path to join(homedir(), '.fazm', 'mcp-servers.json')
- existsSync check; if the file is missing, loader is a no-op
- readFileSync + JSON.parse with a typed Record<string, ServerEntry> expectation
- For each server: skip if enabled === false
- For each server: log and skip if command is missing or empty
- For each server: convert env object to the SDK's { name, value } array form
- For each server: push onto the same servers array the built-ins were pushed onto, so order is built-ins first, users after
- Wrap the entire loop in try/catch; on failure, log the error and return built-ins alone
- Call emitMcpServers(servers) so the Swift UI gets an up-to-date list with builtin flags
Verify every claim on this page locally
Every number, file name, commit SHA, and line number above is reproducible from the public repo at github.com/mediar-ai/fazm. If you want to audit the page rather than trust it, here is the shell sequence.
Why the accessibility-API side of the product matters here
One of the five built-ins, macos-use, is not a screenshot-based agent wrapper. It drives Mac apps through the real macOS accessibility tree, the same tree a VoiceOver user or a UI testing framework would read. The AI receives structured element data (role, title, value, focused state, window), not pixels. That difference is why a consumer MCP picker is interesting in the first place: the agent can answer questions about the app in front of the user without running a vision model, so the cost of adding more servers is actually bounded. A screenshot-first agent has to pay per-turn image tokens; an accessibility-first agent does not.
The file that does the accessibility reads is Desktop/Sources/AppState.swift, around line 439. The agent sees button labels, the focused window title, and element roles before it sees anything else. MCP servers become incremental tools on top of that substrate, not a replacement for it.
The takeaway, if you build consumer AI products
Consumer distribution of open protocols is its own story. Every model release in April 2026 was covered; the first consumer app to make an open protocol configurable without terminal access was not. The pattern will repeat with MCP's successors and with other protocols that exit the developer niche. Watch the release notes, not the benchmarks, if you want to see that crossing happen.
Build a picker, not a preference. MCP is a protocol with enough metadata (name, command, args, env) that a small typed form covers the full range of real configs. Fazm's MCPServerEditSheet is 209 lines. If you ship a consumer AI app and your users eventually need to extend it, the form beats the textarea beats the docs link.
Match your file format to an existing developer convention. The file at ~/.fazm/mcp-servers.json is the same shape as Claude Code's mcpServers config. That costs nothing and means a developer's existing config is one cp away from working in Fazm. Picking a new shape would have cost a compatibility story for no gain.
“The cost of letting a non-developer add an MCP server on Mac went from infinite (fork the repo, rebuild) to about ninety seconds. That is the release in one sentence.”
One last number
The headline change of v2.4.0 is 360 new lines of code across three files. It unblocks an unknown, potentially unbounded number of MCP servers you can plug into a consumer Mac app without ever opening Terminal.
Want to see v2.4.0's MCP picker live on your Mac?
Book a 15-minute walkthrough. I'll open the Settings sheet, add a Linear server in under a minute, and show how the mcp_servers_available message updates the built-in versus custom split in real time.
Frequently asked questions
What is the most interesting open source AI update from April 2026 that no roundup covers?
Every roundup for April 2026 leads with Llama 4 Scout (April 2), Qwen 3 72B (April 5), Codestral 2 (April 8), and OpenAI's Codex Labs launch on April 21. Those are real stories. The one they all miss: between April 16 and April 20, 2026, Fazm (github.com/mediar-ai/fazm, MIT-licensed) shipped the first signed-and-notarized consumer macOS app where a non-developer can add, edit, and toggle MCP servers from a settings panel. Commit 2152e6a3 at 17:56 PT on April 16 added the ~/.fazm/mcp-servers.json loader to acp-bridge/src/index.ts (37 lines). Commit 9840b05f two minutes later added MCPServerManager.swift (114 lines). Commit 8c5a7b03 at 12:45 PT on April 17 added the Settings UI sections. The release shipped 3 days later, on April 20, 2026 at 10:41 PT, as v2.4.0.
Why does a consumer-grade MCP picker matter more than another foundation model drop?
MCP (Model Context Protocol) was open-sourced by Anthropic in November 2024 as a way for AI clients to connect to external tools. For sixteen months, the only real clients were developer tools: Claude Code, Cursor, Cline, and a handful of terminals. Configuration meant hand-editing JSON in a dotfile. The v2.4.0 release on April 20, 2026 is the first time a non-technical user on macOS can open an app, click Settings, click MCP Servers, click Add, fill in command and args, and get a new tool in their AI assistant without ever opening a terminal. That is a different audience than a Llama 4 benchmark reader, and it expands who MCP is for.
What are the exact five built-in MCP servers Fazm bundles?
Line 1266 of acp-bridge/src/index.ts declares the list verbatim: const BUILTIN_MCP_NAMES = new Set(["fazm_tools", "playwright", "macos-use", "whatsapp", "google-workspace"]). fazm_tools is Fazm's own tool bridge, a Node stdio process that connects back to the app over a Unix socket. playwright is @playwright/mcp, pinned in package.json. macos-use is a native macOS accessibility automation binary bundled with the DMG. whatsapp is a native WhatsApp Catalyst controller, also bundled. google-workspace is a Python MCP server with PYTHONHOME pointed at a bundled .venv, loading client_secret.json from ~/google_workspace_mcp/. All five are hardcoded; the flag emitMcpServers reports them with builtin: true. User-added servers have builtin: false.
What exactly is the format of ~/.fazm/mcp-servers.json?
The format matches Claude Code's mcpServers object. Top-level keys are server names. Each value is an object with command (required string), args (optional string array), env (optional object of string-to-string), and enabled (optional boolean, defaults to true). Example: {"linear": {"command": "npx", "args": ["-y", "@linear/mcp"], "env": {"LINEAR_API_KEY": "lin_api_..."}}, "github": {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "enabled": false}}. Servers with enabled: false are skipped on bridge startup. Servers with a missing command are logged as skipped and not connected.
How do I verify the commit and file locations myself?
Clone github.com/mediar-ai/fazm and run four commands. git show 2152e6a3 --stat shows +37 lines on acp-bridge/src/index.ts, author date Thu Apr 16 17:56:47 2026 -0700. git show 9840b05f --stat shows +114 lines on Desktop/Sources/MCPServerManager.swift. grep -n BUILTIN_MCP_NAMES acp-bridge/src/index.ts shows line 1266. grep -n fazmDir.appendingPathComponent Desktop/Sources/MCPServerManager.swift shows the ~/.fazm/mcp-servers.json path resolution. Every number, line, and file name on this page comes from running those commands against the public repo at main.
Is this really the first consumer MCP app or just one of the early ones?
It is the first MIT-licensed, signed, notarized macOS consumer app I can find where MCP server management is a top-level settings-panel feature, not a hidden config file. Claude Code is a CLI. Cursor and Cline are developer editors. Claude Desktop supports MCP but its UI for adding servers is still a JSON edit button that opens a text file; v2.4.0 of Fazm gives you a dedicated editor sheet (MCPServerEditSheet.swift, 209 lines) with fields for name, command, args, env, and an enabled toggle, plus a live Active Servers list that shows built-in versus user status emitted via the mcp_servers_available message. If a reader knows of an earlier consumer implementation with those properties, the claim should be downgraded; until then, April 20, 2026 is the shipping date I am willing to defend.
How does Fazm's accessibility-API approach differ from screenshot-based AI agents?
Most screen-understanding AI agents take periodic screenshots and run a vision model to parse them. That is fine for prototypes and expensive at scale. Fazm reads the user's focused window through the native macOS accessibility tree (AXUIElement, kAXFocusedWindowAttribute, kAXTitleAttribute, kAXRoleAttribute, kAXValueAttribute). The AI sees structured element data: button labels, window titles, text field values, element roles. That means when a user asks Fazm about the thing they are looking at, the answer does not wait on a vision model to describe the screen, because the screen is already structured text. The bundled macos-use MCP server extends the same approach to automation: it drives UI across any Mac app, not just the browser. That is why an MCP story ends up coupled to an accessibility-API story: both are about the agent knowing the real state of the machine without screenshots.
What other updates shipped in the Fazm v2.4.0 release on April 20, 2026?
The CHANGELOG.json entry under 2.4.0 lists ten items. The headline is the MCP picker (custom servers via ~/.fazm/mcp-servers.json with Settings UI to add, edit, and toggle). The second is dynamic model population from the ACP agent, so new Claude models appear without an app update. The third is a Referrals section in Settings with a $49 credit banner on the paywall. Four items are bug fixes (follow-up messages, mid-word bubble splits, chevron hit area, built-in mode paywall). Two are pricing tweaks (paywall after 3 messages, 21-day free trial shortened to 1 day). One is an ACP protocol upgrade to v0.29.2 which became the foundation for the April 22 default-Opus unblock.
Why is the user config file location ~/.fazm/mcp-servers.json and not ~/Library/Application Support/?
Because it mirrors Claude Code's convention of putting user MCP config at ~/.<app>/mcp-servers.json or equivalent dotfiles. The trade-off is macOS-idiomatic (Application Support) versus developer-idiomatic (dotfile in $HOME). Fazm chose developer-idiomatic for a specific reason: users who add their own MCP servers usually already have MCP configs for other clients, and they want a grep-able JSON file they can version-control or sync across machines. A buried Application Support path hides the file from exactly the users most likely to want it. The MCPServerManager.swift init resolves the path as FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(".fazm").appendingPathComponent("mcp-servers.json").
If I am not on macOS, does any of this help me?
The consumer app only ships as a signed macOS DMG, so direct use means a Mac. The angle still transfers. If you are building a consumer AI app on any platform, the v2.4.0 release is a working example of how to surface an open-source protocol to non-developers: hardcode the essentials as built-ins, expose a file format that matches the developer convention, then wrap a typed settings panel around the file. The 37-line loader in acp-bridge/src/index.ts is the entire parse-and-append step; the 114-line MCPServerManager.swift is the entire persistence and observation layer; the 209-line MCPServerEditSheet.swift is the entire UI. Those three files are the reference implementation.
What changed in the wider Fazm codebase between April 1 and April 24, 2026?
Roughly 300 commits on main. The major surface-area changes: attachments system (drag-and-drop, paste, file-and-image support) between April 1 and April 10. ACP protocol upgrade to v0.25 (April 7) and then v0.29.2 (April 19). MCP custom-server feature (April 16-17). MCP settings UI (April 17). v2.4.0 release (April 20). v2.4.1 release with a fazm_features system-prompt block (April 22, commit 2c09d26a). Post-release Opus default restoration (April 22 evening, commit a767a55f). The MCP feature is the single change that expands what the product can do for users; everything else either restores prior intended behavior or ships ACP-side fixes.