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.

Top comments (2)
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!