April 2026, the MCP monthOne JSON file, every new toolSame format as Claude Code

The April 2026 productivity tool wave has a shared format. Fazm reads it from one file.

Every productivity tool roundup this month lists the same features. None of them point out the bigger shift: productivity tools started shipping MCP servers as first-party surfaces, and a desktop Mac chat can now mount any of them through a single 19-byte path, ~/.fazm/mcp-servers.json, in the exact format Claude Code already uses.

F
Fazm
10 min read
4.9from 200+
Sourced from Fazm acp-bridge/src/index.ts and Swift source
Config format mirrors Claude Code's mcpServers block
No per-tool adapter code, no Fazm release required

Productivity tools with shipping or updated MCP servers in April 2026

Notion Workers for AgentsLinear MCPGitHub MCPSentry MCPSlack MCPSupabase MCPVercel MCPCloudflare MCPStripe MCPPostHog MCPPostgres MCPFilesystem MCP

The story of April 2026 is not a feature list. It is a protocol list.

Every productivity-tools roundup this month reads like the last one. Notion shipped something, Linear shipped something, Todoist shipped something. Stop. Re-read the release notes. Most of what shipped is not a new sidebar. It is a new tool endpoint that speaks MCP, the Model Context Protocol that Anthropic published in late 2024 and that every major AI chat now consumes.

Notion 3.4 Part 2 introduced Workers for Agents on April 14. Linear's MCP endpoint picked up sub-issue cascade coverage. Sentry, GitHub, Stripe, Supabase, Cloudflare, PostHog, and Vercel polished or extended their first-party MCP servers during Q1 and April. The interesting question is not what each one added. It is: once every productivity tool speaks the same protocol, what is the minimum code path on your Mac to reach all of them from one chat?

For Fazm, that path is a 19-byte filename.

0JSON file Fazm reads for all MCP productivity tools
0Fields per entry: command, args, env, enabled
0Lines of bridge code that load it (index.ts 1102-1137)
0Per-tool adapters, anywhere in the Fazm binary

The anchor fact: ~/.fazm/mcp-servers.json

If this guide leaves you with one thing, it is this path. Every user-defined MCP productivity tool you want Fazm to reach sits in this single JSON file in your home directory. The file is optional (absent by default, loader short-circuits on existsSync), human-editable, and copy-compatible with anything you already wrote for Claude Code.

acp-bridge/src/index.ts (lines 1102-1137)

Four fields per entry. One file. Every productivity tool that shipped an MCP in April 2026 becomes a single JSON entry.

Every April 2026 productivity tool update, one chat

The diagram below is the mental model. On the left, productivity tools that shipped or maintained MCP servers this month. In the middle, Fazm's bridge reading ~/.fazm/mcp-servers.json and mounting each one as a peer to its own built-in servers. On the right, the user, talking to one chat that now has direct tool access to all of them.

April 2026 MCP tools flow through one JSON file

Notion
Linear
GitHub
Sentry
Stripe
Supabase
Cloudflare
PostHog
Fazm bridge
One Mac chat

What happens on your Mac when you start a new Fazm conversation

01 / 05

1. buildMcpServers() runs

The bridge calls buildMcpServers(mode, cwd, sessionKey) at index.ts line 992. It seeds the list with Fazm's own tools: fazm_tools, playwright, macos-use, whatsapp, google-workspace.

What the shared format actually buys you

Portability across clients

Any mcpServers block that works in Claude Code, Cursor, or Windsurf drops into Fazm unchanged. The inverse is also true: entries you add in Fazm paste into any Claude-Code-compatible config.

Zero Fazm release cadence

When Linear updates its MCP server, you get the update the next time you run npx. No Fazm version bump, no adapter rewrite, no deploy dependency.

One file, diffable in git

The file is plain JSON. Check it into a dotfiles repo, diff across machines, share with teammates. Config portability is a first-class property.

Composable with the AX tree

An MCP tool call and a macOS accessibility click land in the same turn. Pull a Linear issue via MCP, then type its title into Fantastical via AX, same chat, same agent loop.

Built-in vs custom rows in Settings

SettingsPage.swift lines 1786-1830 render built-in servers and custom user servers as two lists. You always know which ones came from the Fazm binary and which ones came from your file.

No lock-in

Because the format is an open spec, you can drop Fazm and keep your tools. Your ~/.fazm/mcp-servers.json copy-pastes into whichever Claude-Code-compatible client you switch to.

Add any April 2026 MCP productivity tool to Fazm in five steps

1

Pick the MCP server for your tool

Most are published as npm packages or standalone binaries. Linear ships @modelcontextprotocol/server-linear; GitHub ships @modelcontextprotocol/server-github; Sentry and Stripe ship first-party binaries.

2

Grab the tool's API credentials

Personal access token, API key, or OAuth. Whatever the MCP server reads from its env. For Linear that is LINEAR_API_KEY; for GitHub it is GITHUB_PERSONAL_ACCESS_TOKEN.

3

Open ~/.fazm/mcp-servers.json

If it does not exist, create it with an empty object: {}. Fazm's bridge short-circuits when the file is missing (existsSync on line 1106).

4

Add a single JSON entry

Four fields: command, args, env, enabled. Model it after the Claude Code docs or copy from an existing .mcp.json you already have.

5

Start a new Fazm conversation

The bridge picks up the file at session start. The log line says 'User MCP server loaded:' followed by name and command. The tool is now callable inside the chat.

What a real entry looks like

This is a minimal ~/.fazm/mcp-servers.json with three April 2026 productivity tools wired up. The keys become the server names shown in the Fazm Settings pane. The command and args lines are exactly what you would write in Claude Code's .mcp.json. Copy, edit credentials, save.

~/.fazm/mcp-servers.json

What the bridge log says when it loads them

Tail the Fazm dev log at /tmp/fazm-dev.log (or production at /tmp/fazm.log) right after opening a new chat. Every user MCP server that mounts is logged at index.ts line 1132. The output is deterministic.

tail -f /tmp/fazm-dev.log

Every entry in this grid drops into ~/.fazm/mcp-servers.json as a single JSON object.

April 2026 productivity tools with live MCP servers

Notion

Workers for Agents (Apr 14) + Views API

Linear

MCP endpoint, sub-issue cascade

GitHub

First-party MCP server

Sentry

First-party MCP, error triage

Slack

Maintained MCP, search + post

Supabase

First-party MCP, DB + auth

Vercel

Deploy + env MCPs

Cloudflare

Workers + AI gateway MCPs

Stripe

First-party MCP, refunds + subs

PostHog

Events + feature flag MCPs

Postgres

Read-only SQL MCP

Filesystem

Anthropic reference MCP

MCP entry vs. the old ways of integrating a productivity tool

The reason MCP matters for April 2026 updates is not aesthetic. Every prior way to add a productivity tool to a desktop agent required more code on the agent's side. MCP flips that: the tool ships its own server, the agent ships a config reader, and the integration collapses into one JSON entry.

FeaturePer-tool adapter in app sourceMCP entry in ~/.fazm/mcp-servers.json
Code you write to integrate a new toolDozens to hundreds of lines of adapter code4 fields of JSON
Fazm release requiredYesNo
Portable across clientsNo, adapter is client-specificYes, same as Claude Code
Updates when tool vendor updatesOnly when adapter is rebuiltAuto on next npx/uvx
Credentials locationHardcoded or secret storeenv field of JSON entry
Auditable at runtimeInspect source or docsSettings > MCP Servers UI pane
Lock-in riskHigh, adapter is client-specificNone, format is open

Built-in, custom, orbit around the same bridge

Fazm's bridge treats its bundled MCP servers and the ones from your JSON file identically once they are mounted. The Settings UI groups them as Built-in and Custom for clarity, but at protocol level they are peers.

Fazm bridgeacp-bridge
playwright (built-in)
macos-use (built-in)
whatsapp (built-in)
google-workspace (built-in)
linear (custom)
github (custom)
sentry (custom)
stripe (custom)

The April 2026 productivity tools with no MCP server yet

Not every tool in April 2026 shipped or updated an MCP. Todoist's new AI views, Fantastical's scheduling suggestion, Logic Pro's mixer assistant, Pixelmator Pro's edit primitives: none expose a public MCP.

For those, Fazm falls back to its macOS accessibility surface. Same chat, different reach. That fallback is covered in detail in the companion guide on productivity apps updates April 2026. For the MCP-native subset, this file and this format is the whole story.

MCP productivity tools one JSON file away

0+

And growing. Any April 2026 productivity tool that publishes an MCP server this month or next is a one-line add to your existing ~/.fazm/mcp-servers.json.

Frequently asked questions

What actually shipped in 'productivity tools' in April 2026 that was not just another app release?

The pattern is the tool layer, not the app layer. Linear, Notion, Sentry, GitHub, PostHog, Slack, Supabase, Vercel, Cloudflare, Stripe, and others either shipped or polished MCP servers in Q1 and April 2026. Notion Workers for Agents (released in the 3.4 Part 2 update on April 14) is the capstone: productivity tools started treating the MCP endpoint, not the marketing site, as their product surface. This is different from 'productivity apps' updates, which refers to the desktop clients. Productivity tools updates in April 2026 are, disproportionately, updates to server-side protocol endpoints.

What specifically is the file path Fazm reads to pick up a new productivity tool?

~/.fazm/mcp-servers.json. It is loaded inside the Fazm ACP bridge at acp-bridge/src/index.ts lines 1102 to 1137 via readFileSync and JSON.parse. Each entry has four fields: command, args, env, enabled. Changes take effect on the next conversation, no restart required. The Settings UI in Fazm even has a button labeled 'Open' that calls NSWorkspace.shared.selectFile on that exact path at SettingsPage.swift line 1854. You do not need the Settings UI; the JSON file is canonical.

What does the format look like and why does it match Claude Code?

The format is literally `{ "name": { "command": "...", "args": [...], "env": {...}, "enabled": true } }`. The comment at acp-bridge/src/index.ts line 1103 says: "Format mirrors Claude Code's mcpServers". The label in Fazm Settings UI at SettingsPage.swift line 1844 says: "Uses the same format as Claude Code." So any `mcpServers` block you have been using in `.mcp.json` for Claude Code, or in Cursor's config, or in any other Claude-Code-compatible client, copy-pastes into Fazm as-is.

If I installed, say, the Linear MCP server today, what are the exact steps to add it to Fazm?

Open ~/.fazm/mcp-servers.json. If the file does not exist, create it with an empty `{}`. Add an entry: `"linear": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-linear"], "env": { "LINEAR_API_KEY": "..." }, "enabled": true }`. Save. Start a new Fazm conversation. The bridge spawns the process via stdio, lists the tools it exposes (issue creation, cycle management, sub-issue cascade), and makes them available alongside Fazm's built-in macOS accessibility and Playwright tools. That is the full workflow. Zero Fazm binary changes, zero per-tool adapter code.

How is this different from the accessibility-tree automation Fazm already has?

They are complementary, not redundant. The macOS accessibility surface drives any Mac app that has no public API: click buttons in Logic Pro, type into Fantastical, toggle panels in Pixelmator Pro. The MCP surface talks to any service that ships a proper tool server: query Linear issues, mutate Notion databases, tail Sentry errors, trigger a Stripe refund. Same chat, same turn, different reach. A productivity workflow like 'read the failing Sentry error, find the related Linear issue, type a root-cause note into Fantastical' uses all three in one session.

Is there anything in the Fazm codebase that confirms the MCP list at runtime?

Yes. The bridge emits a `mcp_servers_available` event on every session start, built at acp-bridge/src/index.ts line 1261: `send({ type: "mcp_servers_available", servers: payload })`. The Swift side parses it in ACPBridge.swift and updates MCPServerManager.shared.activeServers at MCPServerManager.swift lines 117 to 121. That property drives the Settings page 'Built-in' vs 'Custom' list in SettingsPage.swift at lines 1786 to 1830. So every running Fazm shows you, in a built-in UI pane, exactly which MCP productivity tools are loaded right now.

Which April 2026 productivity tool updates ship MCP servers out of the box today?

Notion (with Workers for Agents, April 14), Linear (active MCP endpoint, sub-issue cascade exposed), GitHub (first-party MCP server), Sentry (first-party MCP), Slack (community plus Anthropic maintained), Supabase (first-party), Vercel (deploy and env MCPs), Cloudflare (multiple MCPs), Stripe (first-party), PostHog (event and feature flag MCPs). Todoist and Fantastical do not ship MCPs yet; for those, Fazm falls back to the accessibility surface. Any April 2026 productivity tool that publishes an MCP server becomes a one-line add to ~/.fazm/mcp-servers.json with no Fazm release required.

Will older Claude Code mcpServers blocks really paste in without edits?

Yes, with one caveat. The Claude Code format has an optional `type` field (http, sse, stdio). Fazm's loader at acp-bridge/src/index.ts line 1108 types the JSON as stdio by default. If your block uses `type: "http"`, configure the HTTP MCP variant on the Fazm side via the McpServerConfigHttp shape at index.ts lines 983 to 988. For the 90 percent case (stdio, spawned binary or npx package), it is a verbatim paste.

Does Fazm ever disable a user MCP server without asking?

Only if you set `enabled: false` yourself. The loader's single gate at acp-bridge/src/index.ts line 1115 is `if (cfg.enabled === false) continue;` and its only other safety check is `if (!cfg.command) continue;` at line 1116. Entries with a valid command and enabled not equal to false always mount. There is no allowlist, no remote block, no telemetry that strips servers.

Can I verify the MCP servers that are actually running in a given session?

Two ways. First, check the Fazm log; the loader logs every user MCP server it loads at index.ts line 1132: `logErr("User MCP server loaded: ${name} (${cfg.command})")`. Second, open Fazm Settings to the MCP Servers tab. You will see a 'Built-in' section with playwright, macos-use, whatsapp, google-workspace (if available) and a 'Custom' section with every entry from your JSON that was successfully mounted. The rows are driven by the `activeServers` published property updated at MCPServerManager.swift line 117.

Add your April 2026 productivity tools to one Mac chat

Download Fazm, drop every MCP you already run into ~/.fazm/mcp-servers.json, and drive them in the same turn as your desktop apps. No adapters, no SDK wrappers, no release cadence.

Download Fazm
fazm.AI Computer Agent for macOS
© 2026 fazm. All rights reserved.

How did this page land for you?

React to reveal totals

Comments ()

Leave a comment to see what others are saying.

Public and anonymous. No signup.