Supabase updates April 2026: where the release notes actually land on your Mac
Multigres open-sourced, GitHub integration on every plan, Stripe Projects co-design, ssh supabase.sh setup | claude, Studio Fix-with-Assistant, and pg_graphql going default-off in about three weeks. Six headlines. Two Mac surfaces. This guide walks the release notes, then drops into the exact file and line where Fazm already reads both surfaces in one tool-calling loop.
April 2026 release notes at a glance
Every chip is a release-note item. Every chip lands on one of two surfaces on your Mac.
What every April 2026 Supabase roundup gets right, and what they all miss
The ten top-ranking results for this keyword all cover the same surface. supabase.com/changelog, the supabase/supabase GitHub releases page, the supabase-js releases page, releasebot.io, the Supabase release-notes blog tag, the changelog discussion category, the January 2026 dev update, and the v1.26.04 release tag all enumerate the same six things: Multigres as an open-source Kubernetes operator, GitHub integration on every plan, Stripe Projects co-design, the docs pipe to Claude Code, Studio Fix-with-Assistant, and pg_graphql default-off in about three weeks. All of that is accurate and useful.
What those articles skip, because it is outside Supabase's scope to write about, is where the release notes physically land on the user's machine. Every one of those six entries is either a button you click in Studio (which runs in Chrome) or a command you type at a terminal (which runs in Terminal.app or iTerm2). There is no third surface. The release notes describe a set of new things you can do, and every one of those things happens through one of two pieces of software already on your Mac.
This guide walks the six release-note entries and then drops into the exact file-and-line where Fazm already treats you as a Supabase user before the first tool call, and where the same ACP bridge process wires both surfaces into one tool-calling loop.
The six April 2026 release-note entries
Two infrastructure items, two integration items, one docs item, and one default-policy item. Read the list and ask, for each one, which of the two Mac surfaces it touches.
Multigres Kubernetes operator open-sourced
Direct pod management, zero-downtime rolling upgrades, pgBackRest PITR, OpenTelemetry tracing. Lands in your cluster, surfaces in Studio.
GitHub integration on every plan
Free-tier projects can now connect a repo and deploy migrations from main via CI/CD. No preview branching required.
Supabase as a Stripe Projects co-design partner
A new Terminal CLI provisions Supabase plus Vercel plus Clerk side by side and writes credentials into your local .env.
Docs pipe to Claude Code
`ssh supabase.sh setup | claude` streams the full Supabase reference straight into a coding agent session. Pure stdin.
Studio Fix-with-Assistant
Dropdown across touchpoints to send the current error or SQL to Claude or ChatGPT. Inside the Studio tab.
pg_graphql default-off in ~3 weeks
Policy change on new projects. Smaller exposed API surface by default. Toggle moves from on to off in Database > Extensions.
Multigres and pg_graphql: Studio. GitHub integration and Fix-with-Assistant: Studio. Stripe Projects and ssh supabase.sh setup | claude: Terminal. Six out of six map cleanly onto one of two surfaces.
One surface at a time vs one loop that sees both
Before a Mac-level agent, each Supabase workflow involved the human as the context-switcher between Studio and Terminal. The April 2026 release notes do not fix this; they ship more of both surfaces. What fixes it is an agent that holds both in the same loop.
How a multi-surface Supabase workflow runs
You read the release notes. You hop to Studio to check the Multigres pod rollout. You alt-tab to Terminal to run `supabase db push`. You alt-tab back. Your AI assistant can see one window at a time, if any.
- Two browser-based fixes (Studio Fix-with-Assistant, future Assistants) can only see the Studio tab.
- Claude Code piped from supabase.sh sees stdin only.
- Neither side reads the accessibility tree of the other.
Anchor fact 1:
Fazm already classifies supabase.com as a work/dev tool before any model runs
This is the block in Fazm that recognizes a Supabase user before the agent's first tool call. ChatToolExecutor imports AutofillExtractor on line 2, Package.swift pulls in the ai-browser-profile-swift-light package at line 18, the library's Constants.swift line 134 maps supabase.com to Supabase, and HistoryExtractor.swift line 49 tags the service with ["work", "dev"] alongside GitHub, GitLab, Vercel, Netlify, Firebase, and CodeSandbox.
Why this matters for a Supabase workflow: the profile entry lands in ~/ai-browser-profile/memories.db as tool:Supabase with tags [account, tool, work, dev]. When you ask Fazm about a migration or a pod rollout, the agent's memory already has Supabase present, so prompt routing does not have to guess.
Anchor fact 2:
the same ACP bridge registers Playwright-over-CDP and macos-use in one array
This is the registration block that collapses the two Supabase Mac surfaces into one tool-calling loop. Line 1030 pushes --extension onto Playwright's spawn args when PLAYWRIGHT_USE_EXTENSION === "true", which makes Playwright MCP attach to your real running Chrome over the Chrome DevTools Protocol instead of launching an empty Chromium. Lines 1056 to 1064 guard-register the native mcp-server-macos-use binary with args: [] and env: [] into the same MCP servers array.
Two registrations, one process, one MCP host, two tool namespaces (mcp__playwright__* and mcp__macos-use__*). The agent's tool list covers the browser surface and the terminal surface at the same time, with your Supabase Studio authentication inherited from your running Chrome.
Which Mac surface each April 2026 release-note item lands on
All six headline entries connect through the Fazm ACP bridge into one of two output surfaces: a logged-in Chrome tab on Supabase Studio, or a Terminal window running the supabase CLI. Both surfaces are reached by the same MCP host.
April 2026 release items -> Fazm ACP bridge -> two Mac surfaces
One tool-calling turn, one user, two surfaces
This is what the round trip looks like for a request that spans the April 2026 Multigres update (Studio) and a migration push (Terminal). No user alt-tab, no second auth, one answer at the end.
apply migration + check Multigres pod rollout
From a fresh Fazm launch to a Supabase answer, hop by hop
Before the model runs anything, Fazm classifies you
AutofillExtractor scans your Chrome history, finds `supabase.com`, looks it up in serviceNames (Constants.swift:134), and writes a ProfileEntry with `tool:Supabase` and tags `[account, tool, work, dev]` into ~/ai-browser-profile/memories.db.
The ACP bridge wires both Mac surfaces in one process
acp-bridge/src/index.ts starts. Line 1030 conditionally adds --extension to Playwright's args so Playwright MCP attaches to your running Chrome over CDP. Lines 1056-1064 guard-register the `mcp-server-macos-use` binary into the same servers array with empty args and env.
You ask for a Supabase thing in natural language
Example: 'apply the new migration to my-app-prod and check the Multigres pod rollout in Studio'. The model now has tools that cover both the browser and the terminal in the same toolset, plus the ProfileEntry that says you own supabase.com.
The same turn drives CLI + Studio
The model calls `mcp__macos-use__type_and_traverse` to type `supabase db push` into the frontmost Terminal window. The accessibility tree returns with the command output. Then it calls `mcp__playwright__browser_navigate` to Studio's Infrastructure page, reads the pod status from the AX snapshot, and returns a single answer.
The loop ends with an observation, not a screenshot
The Playwright MCP snapshot is a `[ref=eN]` YAML file on disk, not base64 bytes inline. The macos-use response is a text AX tree. The model reads both as text.
What the April 2026 release notes look like at the prompt
Three of the six release-note items are Terminal-native: the docs pipe to Claude Code, Stripe Projects, and the baseline supabase CLI the Multigres and GitHub-integration entries both lean on. Here is the shape a Mac agent sees inside the Terminal AX tree when these commands run.
Every one of those commands reaches the Terminal window through a single mcp__macos-use__type_and_traverse call with a pressKey="Return" parameter, which types and submits in one tool-call round trip.
Why `supabase.sh | claude` is useful but still one-surface
The April 2026 docs-pipe release is a real quality-of-life improvement for coding agents inside the terminal. It is not, however, a second surface. Compare a Terminal-only Claude Code flow against a Mac-level agent that also drives Studio in the same turn.
Where the ceiling is: stdin vs Studio + Terminal in one loop
# Terminal-only agent (e.g. Claude Code)
ssh supabase.sh setup | claude
> apply migration 20260419_init_schema
> check Multigres pod rollout
# agent runs:
$ supabase db push
# output read via stdout, ok
# but: no way to read Studio
# for pod rollout status,
# kubectl was never wired up,
# and the user is the one
# who has to alt-tab to Chrome.
# scope: stdin / stdout / subprocessApril 2026 release-note entries mapped to Mac surfaces
For each headline entry, where does the action actually happen, and what tool does Fazm call to reach it?
| Feature | Native Mac surface it lands on | Fazm agent tool call |
|---|---|---|
| Where Multigres pod state is read | Supabase Studio > Infrastructure (browser) | Playwright --extension against your logged-in Chrome tab |
| Where a `supabase db push` migration runs | Terminal.app or iTerm2 (native macOS) | macos-use_type_and_traverse into the frontmost Terminal window |
| Where the GitHub-integration connect-repo dialog lives | Supabase Studio > Project Settings > Integrations | Playwright browser_click on a `[ref=eN]` from the AX tree snapshot |
| Where Stripe Projects prompts for a region | Terminal prompt inside the `stripe projects new` CLI | macos-use_type_and_traverse with pressKey=Return in one call |
| Where pg_graphql gets toggled off | Supabase Studio > Database > Extensions | Same Chrome tab, same session cookie, same 2FA state |
| Where `ssh supabase.sh setup | claude` lands | Terminal, piped into Claude Code | Terminal, typed by the agent via one `_and_traverse` call |
| Auth state reused across the loop | Yes: your real Chrome cookies, 2FA, WebAuthn | PLAYWRIGHT_USE_EXTENSION="true" on acp-bridge/src/index.ts:1030 |
| Tool-call surfaces held by one MCP host | playwright + macos-use in the same servers.push array | acp-bridge/src/index.ts lines 1049-1054 and 1056-1064 |
The shape in numbers
Not benchmarks. These are counts and counts only: what the April 2026 release notes contain, what they require of the machine they land on, and how the Fazm ACP bridge wires both.
Six release-note headlines land on 0 surfaces, and one ACP bridge process holds 0 MCP servers in the same array, which is why 0 tool-calling loop is enough.
What the Studio dashboard looks like to a Mac agent
The Supabase Studio dashboard, when read as an accessibility tree snapshot via Playwright MCP, resolves to compact YAML nodes with [ref=eN] identifiers the agent clicks by. One node for the new GitHub-integration connect-repo button looks like the line below.
- button [ref=e214] "Connect GitHub repository" /settings/integrations
The agent substring-matches Connect GitHub repository, reads ref=e214 from the same line, and calls browser_click(ref="e214"). No screenshot, no pixel coordinates, no VLM.
What you need to make this work on your Mac
- Install Fazm on your Mac (one DMG).
- Grant Accessibility permission in System Settings > Privacy & Security.
- Sign into Supabase Studio in Chrome once (2FA, passkeys, session cookie).
- Install the Playwright extension in the same Chrome profile.
- Start Fazm. The ACP bridge reads your history and tags supabase.com as a work/dev tool.
- In a chat, ask a Supabase question that spans Studio and CLI. Done.
Fazm ships no Supabase integration. You install Fazm, grant Accessibility, sign into Studio once. The ACP bridge handles the rest via Playwright-over-CDP and mcp-server-macos-use.
How to read future Supabase release notes on a Mac
Every future Supabase release will grow the set of things you can do through Studio and through the supabase CLI. Expect more infrastructure-layer items like Multigres. Expect more integration items like GitHub-on-all-plans. Expect more in-product assistants like Fix-with-Assistant. Expect more default-policy changes like pg_graphql.
What you should not expect, because it is not what Supabase ships, is a line item that gives a Mac-level AI agent shared tool access to both your Studio dashboard and your Terminal in one tool-calling loop. That layer lives one level up, in the client that hosts the model. For Fazm that client is the ACP bridge, and the registration at acp-bridge/src/index.ts lines 1056 to 1064 already wires the Terminal surface in with zero Supabase-specific code.
The release-day question for a Mac user is not "did Supabase grow"; it is "did the client on my Mac that drives Studio and the CLI grow". The answer is usually no, because the client did not need to. That is the decoupling a Mac-level agent buys you.
Want to see one Fazm turn drive Supabase Studio and the supabase CLI at once?
Thirty minutes. We open acp-bridge/src/index.ts at line 1030 and line 1057, point at your own Supabase project, and run a migration + a Studio check in the same agent turn.
Book a call →Frequently asked questions
What did Supabase actually ship in April 2026?
Six headline items. Multigres was open-sourced as a Kubernetes operator with direct pod management, zero-downtime rolling upgrades, pgBackRest PITR backups, and OpenTelemetry tracing. GitHub integration moved to every plan, so a free-tier project can now connect a repo and deploy migrations from main via CI/CD without a preview-branch dance. Supabase became a co-design partner for Stripe Projects, a new Terminal CLI that provisions Supabase, Vercel, Clerk, and other services side by side and writes the resulting credentials into your local .env. The docs got pipeable: `ssh supabase.sh setup | claude` streams the full Supabase reference straight into Claude Code. Studio grew a Fix-with-Assistant affordance across its touchpoints, with a dropdown that sends the current error or query to Claude or ChatGPT. And pg_graphql was announced as default-off on new projects in about three weeks, narrowing the exposed API surface.
What do all of those updates have in common from a Mac user's perspective?
They all land on exactly one of two surfaces on your Mac. Multigres, GitHub integration, pg_graphql defaults, and Fix-with-Assistant show up in the Supabase Studio dashboard at app.supabase.com, which runs inside Chrome. Stripe Projects and `ssh supabase.sh setup | claude` run in Terminal. There is no third surface. Every release-note item ends as either a button you click in a browser tab or a command you type at a shell prompt. That is the physical shape of the April 2026 changes on an actual Mac.
Where is the exact file in Fazm that already treats me as a Supabase user?
Two lines, one library. Fazm's macOS target depends on `ai-browser-profile-swift-light` (Desktop/Package.swift line 18, product imported on line 39 as BrowserProfileLight), and ChatToolExecutor.swift line 2 declares `import AutofillExtractor`. Inside that library, Constants.swift line 134 contains the literal string `"supabase.com": "Supabase",` inside a Swift dictionary called `serviceNames`. And HistoryExtractor.swift line 49 runs the check `if ["GitHub", "GitLab", "Vercel", "Netlify", "Supabase", "Firebase", "CodeSandbox"].contains(service) { tags += ["work", "dev"] }`. When you grant Fazm Accessibility permission and it scans your Chrome history, every visit to supabase.com becomes a ProfileEntry with `tool:Supabase` as the key and `[account, tool, work, dev]` as the tag set. That entry is persisted to `~/ai-browser-profile/memories.db` before any agent turn starts.
How does the same Fazm session drive both Studio and the supabase CLI in one tool-call loop?
In one file, one array. `acp-bridge/src/index.ts` line 1028 opens a local array called `playwrightArgs`, and line 1030 pushes `--extension` onto it when `PLAYWRIGHT_USE_EXTENSION === "true"`. That flag tells Playwright MCP to attach to your already-running Chrome over the Chrome DevTools Protocol instead of launching a driver-owned Chromium with an empty profile. Your Studio session, your sb-access-token cookie, your 2FA state, and your WebAuthn passkey are already in that Chrome process, so the agent inherits them without logging in. Lines 1057 through 1064 of the same file are a guarded `servers.push({ name: "macos-use", command: macosUseBinary, args: [], env: [] })` call that registers the native `mcp-server-macos-use` binary (shipped inside the app bundle at Fazm.app/Contents/MacOS/mcp-server-macos-use) into the same MCP servers array the bridge hands to the ACP session. So the same turn can call `browser_navigate` on `https://supabase.com/dashboard/project/<ref>` and then `click_and_traverse` on the Terminal window to run `supabase db push`, without switching context, without re-authing, and without a second MCP process.
Does the Multigres Kubernetes operator change anything about how a Mac agent should talk to it?
Not at the agent layer. Multigres deploys inside your Kubernetes cluster and is driven from kubectl or the Supabase Studio dashboard surfacing operator state. From a Mac-side agent standpoint, kubectl lives in Terminal and Studio lives in Chrome, which is exactly the same two-surface shape as every other April 2026 release entry. The Multigres open-sourcing matters because you can now run the operator against your own cluster and, via Fazm, have the agent read the pod list from Studio while kicking a `kubectl rollout status` in Terminal in the same loop. The perception layer (AX tree walk of the Studio dashboard) and the action layer (CGEvent-driven keystrokes in Terminal) do not know the word Multigres, and they do not need to.
Can Fazm take advantage of `ssh supabase.sh setup | claude` directly?
Yes, through the Terminal surface. `ssh supabase.sh setup | claude` is a shell pipeline that streams the entire Supabase documentation into a Claude Code session. On a Mac, that runs inside Terminal.app or iTerm2. Fazm's `mcp-server-macos-use` binary exposes six tools suffixed `_and_traverse`, one of which is `type_and_traverse`, that can type the command into the frontmost Terminal window by AX title match and press Return in the same call (the `pressKey` parameter handles the combined click-type-press in one round trip). The agent does not need an SSH MCP server or a Claude Code MCP server; the command is just text typed into a real terminal, and the accessibility tree comes back with the typed output as text.
How does Studio's new Fix-with-Assistant dropdown compare to a Mac-level agent that can see beyond the tab?
Fix-with-Assistant is scoped to the Studio tab. It reads the error or SQL you point at, sends it to Claude or ChatGPT, and returns a fix inside the same dashboard UI. That is useful, and it is what Supabase could ship from inside their own product. A Mac-level agent has a wider camera: it can read the Studio error, read the last ten lines your `supabase functions serve` printed in Terminal, read the migration file your editor has open, and stitch all three into the prompt before replying. The ceiling is not model quality, it is observation scope. Studio's assistant sees the tab. A Mac agent sees the desktop.
Does Fazm rely on any Supabase SDK, or ship Supabase-specific code?
No. `acp-bridge/package.json` has zero Supabase dependencies. No `@supabase/supabase-js`, no `postgrest`, no `supabase-py`. Desktop/Package.swift does not include the supabase-swift package. The only Supabase literal in Fazm's compiled output is the single `"supabase.com": "Supabase",` entry inside the AutofillExtractor domain map (Constants.swift line 134) and the Supabase string in the dev-tool tag list (HistoryExtractor.swift line 49). Everything else the agent does with your Supabase account happens through Playwright pointed at the Studio DOM and macos-use pointed at the `supabase` CLI in Terminal. Supabase ships no Fazm integration. Fazm ships no Supabase integration. The two meet through the user's own macOS.
What would it take for Fazm to support pg_graphql directly, given it will be disabled on new projects in three weeks?
Nothing on Fazm's side, and that is the point. The pg_graphql default-off announcement is a Supabase-policy change: new projects will have the GraphQL surface off unless the user toggles it in Studio. An agent driving Studio does not care about this change except that one toggle location moves from on-by-default to off-by-default. If the user asks Fazm to enable GraphQL on a new project, the agent navigates to the Database > Extensions page and flips pg_graphql on via Playwright; if they ask it to enforce least-surface, it leaves pg_graphql off. The branching happens in the natural-language prompt, not in Fazm's code. This is the same property the release notes have with every feature Supabase ships: the agent layer is a function of the dashboard plus the CLI, not of the Supabase changelog.
How do I verify the file and line anchors in this guide for myself?
Three reads. First, open `acp-bridge/src/index.ts` in the Fazm desktop source tree and jump to line 1028. You will see `const playwrightArgs = [playwrightCli];` immediately followed by the `--extension` push inside a `PLAYWRIGHT_USE_EXTENSION === "true"` check on line 1030. Scroll to lines 1056 to 1064 and you will see the `existsSync(macosUseBinary)` guard and the `servers.push({ name: "macos-use", command: macosUseBinary, args: [], env: [] })` registration. Second, open `Desktop/Sources/Providers/ChatToolExecutor.swift` and confirm line 2 is `import AutofillExtractor`. Third, if you have built the Desktop target, look inside `Desktop/.build/checkouts/ai-browser-profile-swift-light/Sources/AutofillExtractor/Constants.swift` at line 134 for `"supabase.com": "Supabase",` and `HistoryExtractor.swift` at line 49 for the `["GitHub", "GitLab", "Vercel", "Netlify", "Supabase", "Firebase", "CodeSandbox"]` array. All four anchors reproduce from a fresh clone and a `swift package resolve`.
Adjacent angles on the Mac-agent layer above your backend and your browser.
Related reading
Ollama release notes April 2026: the Mac-desktop boundary v0.21.0 does not move
How Copilot CLI, Hermes, and OpenClaw expand Ollama's inbound surface while leaving the Mac-agent perception + action layer untouched.
Browser automation Selenium vs attach-to-Chrome: the four-line difference
Why a --extension push onto playwrightArgs preserves 2FA, cookies, and Cloudflare trust that any WebDriver-spec tool cannot.
Accessibility tree desktop automation: a 441-element walk beats a 4K screenshot
How an AX tree observation payload fits in a 32K context and a base64 screenshot does not, and why that is the real scaling constraint for Mac agents.
Comments (••)
Leave a comment to see what others are saying.Public and anonymous. No signup.