ReadingResearchRadarInvestment framework
Sign in / Sign up
← Back to reading
NewsMaterial4 min readDisconfirmAI Editorial

PC Watch's Liu Yao: Using Tailscale+SSH to Free Meta Muse from Cloud VMs for Autonomous Programming on a 21-Year-Old Zaurus and a 7-Year-Old Jetson Nano

PC Watch author Liu Yao found that the cloud virtual machine environment of Meta Muse (4-core EPYC + 8GB RAM) limited its coding capabilities. He bridged Muse to local PCs and legacy hardware via Tailscale and SSH, enabling an autonomous development verification loop. Muse completed a Zaurus megademo in 30 minutes and ported llama.cpp to a Jetson Nano after 17 patches to run a 230M parameter LLM, but performance (419.6 tok/s prefill) remained significantly behind Claude Code's optimized results (656.2 tok/s). The author attributes this gap to workflow differences: Claude Code probes behavior first, while Muse guesses and advances quickly.

2026-11-19 05:08 GMT+8

Meta's AI agent Muse runs on a cloud virtual machine with a 4-core EPYC processor and 8GB of memory. This configuration is more than sufficient for daily tasks such as managing emails, scheduling appointments, and setting timed reminders. However, if you want it to write code, compile programs, and verify them on real devices, this virtual machine becomes a cage: it cannot access physical hardware, cannot run tests independently, and must hand over its outputs to humans for verification before receiving feedback.

In November 2026, PC Watch author Liu Yao published a detailed practical record demonstrating a method to bypass this limitation: establishing an encrypted tunnel via Tailscale so that Muse's cloud VM can remotely operate a local PC via SSH, which then serves as a bridge to connect to deeper legacy hardware. The entire chain is structured as follows: Muse VM → Tailscale+SSH → MINISFORUM MS-R1 (12-core ARM, 64GB RAM, Tesla P4 GPU) → Telnet → Sharp Zaurus SL-C1000 (a 2005 Linux PDA with 64MB RAM).

The core value of this bridging lies in granting the AI self-verification capabilities. Within the virtual machine, Muse could only write code, compile install packages, and hand them to humans for execution on physical devices. Once it could directly operate the target device, it could complete the closed loop of 'write → compile → run → screenshot → check → correct' on its own. Liu Yao had Muse develop a megademo on the Zaurus, which launched within 30 minutes—a speed previously unattainable through human verification feedback loops. However, the loop was not perfect: Muse captured images from the frame buffer but did not truly 'see' the screen, resulting in upside-down visuals. After being informed, it flipped the image left-to-right instead. Ultimately, the author had to take a photo of the physical screen and send it to Muse to correct the orientation issue.

Sign in / Sign up
ReadingResearchRadarInvestment framework

A more compelling test involved the NVIDIA Jetson Nano (a 2019 developer board). Liu Yao tasked Muse with running Liquid AI's 230M parameter small language model, LFM2.5-230M, on the Jetson Nano's Maxwell architecture GPU using llama.cpp. This request faced incompatibilities at every turn: the latest version of llama.cpp requires CUDA 12+, whereas the Jetson Nano's JetPack 4.2 only supports CUDA 10.x; the code demands C++17, but JetPack 4.2 only provides C++14; gcc 7 libraries are incomplete; and the integrated GPU imposes additional constraints. Muse repeatedly compiled, read errors, and applied patches, finally succeeding after 17 iterations. The result: a prefill speed of 419.6 tok/s and a decode speed of approximately 13.5 tok/s—usable performance for a seven-year-old board.

However, Liu Yao subsequently handed the optimization work over to Claude Code (Opus 5.5). With the same hardware and model, the final performance reached 656.2 tok/s for prefill and 52.5 tok/s for decode—nearly four times faster in decoding speed. This comparison reveals fundamental differences in workflow structure between the two tools: Claude Code writes a small probe program to run on the physical device first, observes actual behavior, and then proceeds with implementation; Muse tends to advance implementation based on guesses, only retroactively discovering errors. The author attributes this difference to their positioning: 'coding-specific tools' versus 'general-purpose agents.' As a general-purpose agent, Muse's willingness to assist in computer archaeology work is already commendable.

From a broader perspective, Liu Yao's practice points to a counterintuitive conclusion: when AI can generate software infinitely, the rationale for purchasing new hardware diminishes. What gains value are legacy devices that 'will never appear again in the same form factor and price point'—such as a 2005 PDA or a 2019 developer board. AI agents give them a chance at resurrection, provided you can find a way to release the AI from its cloud cage. The author also acknowledged security risks: allowing AI remote access to a home network is akin to the scene in movies where one 'activates Skynet to eliminate a virus.' His mitigation measures include dual encryption via Tailscale and SSH, storing only development data on the local PC, and disconnecting legacy devices from the network after jobs are completed. These boundaries deserve serious evaluation for readers attempting similar approaches.

Sources

  • pc.watch.impress.co.jpPC Watch↗
Continue researching →