Sora Commander is my open-source MCP server that lets ChatGPT read files and run commands on my Windows PC, with a local approval window in between. Until now, ChatGPT was the only AI that could use it.
This week I connected a second one: Muse, Meta's agent, which I use as an independent reviewer. It can now inspect my repositories through Sora Commander — strictly read-only.
Why bother? An honest motivation
A thought had been nagging me: if a Windows Muse app ships someday, does Sora Commander become pointless?
My answer: Sora Commander is really a pair of hands for a chat AI — file access and command execution on my own machine. Hands don't have to belong to one AI. If both ChatGPT and Muse can use the same hands, the tool survives whichever assistant I'm talking to. So I wired Muse in as the first "second client."
With strict conditions:
- Read-only. Command execution must be structurally impossible, not just politely refused.
- Private network only. Nothing exposed to the public internet.
- Token-gated. No shared secret, no entry.
Why Tailscale? The OpenAI tunnel is a dead end for third parties
My first idea was to reuse the OpenAI Secure MCP Tunnel that ChatGPT already uses. It turns out that tunnel is outbound-only and limited to OpenAI's own clients (ChatGPT, Codex, the Responses API). There is no endpoint a third-party MCP client can register against.
So the design became:
- Put my PC and the AI's machine on the same Tailscale tailnet.
- Run a small bridge program on the PC that re-serves Sora Commander's tools over Streamable HTTP — bound only to the tailnet address, behind a token check — with every configured folder demoted to read-only.
- The bridge process has no approval dispatcher attached. In Sora Commander, commands can only run after a local Owner approval; with no dispatcher wired in, there is no path that approves anything. Execution isn't denied by policy — it's absent by construction.
The setup, briefly
- Created a tailnet (GitHub sign-in) and joined both machines: the AI's Linux VM and my Windows PC (
desktop-bal4ibd).
- Placed two files in the checkout's
tools\folder: the bridge (scn_muse_bridge.py) and a launcher. The bridge itself is not public yet — this post is a dev log, not a release announcement. - Generated a one-time token into the config folder (never displayed, never sent in chat — with one deliberate exception during the connectivity test, after which it can be rotated in seconds):
$t = -join ((1..48) | ForEach-Object { '{0:x}' -f (Get-Random -Maximum 16) })
Set-Content -Path "$env:USERPROFILE\.config\sora-commander\muse-bridge-token.txt" -Value $t -Encoding ascii
- Started the bridge:
[bridge] Sora Commander read-only bridge for Muse
[bridge] listening on http://100.126.207.87:8765/mcp (Tailscale only)
[bridge] read-only folders: 4 (from allowed-roots.txt, demoted)
[bridge] commands are denied in this process; no approval window opens here.
Verification results
From the AI's side, against my real PC:
| Check | Result |
|---|---|
| Request without token | 401 — turned away at the gate |
| Tool list | 48 tools |
| Folder listing / file read | Real files read back |
| Git log | Today's real commits |
| Command execution attempt | DENY — nothing ran |
| Approval window on the PC | Never appeared (I watched the screen) |
That last row is the one I care about most. The bridge cannot pop an approval window because the approval machinery simply isn't part of that process.
What's next: an approval-gated exec mode
Read-only was the foundation. The follow-up — already written up as a spec for the implementing AI — is an opt-in execution mode: a separate launcher, a separate token, and the local approval window required for every command, exactly like the ChatGPT path. If the approval wiring fails, the mode refuses to start. Not implemented yet; I'll report back when it runs.
Closing
Sora Commander started as "ChatGPT, meet my PC." It is becoming "any AI I trust, meet my PC — with the same local approval rules." The hands stay mine; the assistants can share them.
Sora Commander is free and open source (AGPL-3.0, developer preview):
https://github.com/kurojack-jp/SoraCommander
A Japanese step-by-step version of this log is on note:
https://note.com/kurojack_jp/n/nb53337113253
Update — later the same day: The exec mode is now built and verified on my machine. Through the same bridge, a second AI can request command execution — and every command still stops at the local approval window. In testing: Approve ran the command exactly once; Reject, closing the window, and letting it time out all ended with the command not started. The bridge code is still unpublished; this remains a dev log.
Update (Nov 17, 2026): the read-only bridge is now public in v0.2.0
- The read-only bridge, its launchers and a setup guide ship in v0.2.0. See docs/muse-bridge.md.
- Read-only access no longer needs a token. The bridge asks Tailscale who is calling and lets in only nodes whose StableID you list. Anything else gets 401.
- The exec mode described above stays in development. It is not offered or documented in the public release.
- I checked the public tree itself from Muse: 48 tools, a real
git_logread, and a command returnedDENYwith no window on the PC. That was on my own setup only; I have not yet confirmed that another account's Muse can join its own tailnet the same way. - Muse is a Meta product. This project is not affiliated with or endorsed by Meta.

Top comments (4)
Brilliant setup using Tailscale for secure remote reachability over an MCP server! Managing secure access layers and network bridging for distributed instances is such a crucial piece when handling remote infrastructure.
Thanks, Ali! The layering was deliberate: Tailscale keeps the bridge off the public internet entirely, a token gate sits inside that, and the read-only scope is enforced by construction — the bridge process has no approval path wired in, so commands are denied structurally rather than by a policy setting. Since posting, the exec mode (with the local approval window) has been verified on my machine too — there's an update at the end of the article. Appreciate you reading!
Having hands that don't have to belong to one AI will still matter once this month's winner is yesterday's news. I want to ask about the second client though: when Muse reads the repo through the bridge, does it see the same folder list ChatGPT does, or did you have to carve out a narrower set for it? I'd be careful to settle that before switching on exec mode.
Exactly the bet I'm making. Assistants will keep swapping places — this month's winner, next month's footnote — but the hands stay the same shape: read files, run a command, check the result, ask me before anything irreversible. If the interface is an ordinary chat plus a local approval window, I can swap the AI behind it without rebuilding anything. The bridge is read-only by construction, so the durable part is the boundary, not the brand — and as of v0.2.0 that bridge ships in the public repo, so the hands aren't tied to my setup alone.