I Put My Muse Agent on a Garmin Watch

I can now press a button on my Garmin Forerunner 570, ask a question, and read an answer from my own Muse agent on my wrist.

The phone stays in my pocket. The answer does not come from a separate chatbot with a blank memory. It comes from the Muse account I already use.

The code is open source: cczhong11/garmin-muse. This is an unofficial personal project, and it is not affiliated with Meta or Garmin.

Why I wanted this

I already wear the watch all day. It has a microphone, a speaker, and a developer platform. I also already use Muse, and the valuable part is not just the model. It is the memory, tools, and account context.

I could have built a small Connect IQ app that calls an LLM API. That would have been easier, but it would have felt like talking to a stranger. I wanted the watch to be another door into the same agent.

Then I noticed Meta’s Muse Gadget SDK, which can turn an ESP32 or Linux computer into a Muse device. That raised the real question:

Can a device start a conversation with Muse, or can Muse only send commands to the device?

I built this with Claude Code. I made the product calls and tested the hardware, while Claude did most of the source reading, implementation, and debugging. We used one rule: do not build a polished watch UI until the risky assumptions pass.

The architecture

Connect IQ is a poor place to reimplement a device protocol, so the watch stays simple. It records audio and sends it over HTTPS. A small Linux service does the Muse work.

Garmin watch
    -> phone via Bluetooth
    -> HTTPS tunnel
    -> Bridge
    -> Linux Muse Gadget
    -> Muse

The first useful discovery came from the Linux SDK. LinkSession has send_chat, send_voice, and subscribe_chat. A device can send a WAV voice note and follow the response. The local socket only exposes text and images, so I added a small service wrapper that calls the public send_voice method.

Testing the riskiest assumption first

Before writing the watch app, I tested memory.

I generated five random facts and saved them in the Muse app. Then the Gadget asked for each one from a brand-new side chat. I also added two decoy keys that were never saved, because a model that guesses confidently could otherwise look correct.

Test Result
Saved facts 5/5 correct
Decoys 2/2 answered UNKNOWN

This does not prove which internal retrieval path Muse used. It might have searched another chat instead of long-term memory. For this project, the useful result was enough: a Gadget session could use information from my account.

What broke

Bluetooth was only needed once

At first I assumed the Linux Gadget needed Bluetooth forever. That would have made a Docker deployment awkward because my NAS has no Bluetooth adapter.

It turns out Bluetooth LE only carries the initial pairing. After that, the Gadget talks to Muse over a WebSocket. So I paired on a Raspberry Pi once, moved the pairing state to Docker on the NAS, and left the Pi out of the runtime path.

The first pairing failed with org.bluez.Error.Busy

The pairing script restarted BlueZ with a few temporary settings, then immediately tried to power on the adapter. Sometimes BlueZ was not ready yet. The fix was simple: wait for the adapter to report Powered: yes, then give it a few more seconds.

My script made it too easy to expose a token

On a retry, the script already had the saved SDK token and did not ask for it. The token was pasted anyway, so the terminal echoed it.

The right response was to treat that token as exposed and replace it. The script now says when a token is already saved and turns terminal echo off while pairing. Small setup scripts still need secure failure modes.

A device agent should not live on your LAN

The Gadget lets Muse run shell commands on the host. That is the point of the SDK, but it deserves respect.

My first container was non-root and read-only, but it could still reach other machines on my network. I moved it to an internal Docker network with no direct route out. A tiny CONNECT proxy now allows only the two Muse hosts it needs on port 443.

The first allowlist was too strict and blocked Muse’s VM host. The proxy log made that obvious, and I added the exact host instead of opening the network.

MTP was the watch debugging boss fight

I copied the app to the watch, but could not find it. At first I blamed the transfer.

The USB product ID told a more useful story. The watch was sometimes in Garmin’s USB mode instead of MTP, so normal tools could not see its files. After switching modes, libmtp could see the device, but its file upload command could not resolve the Apps folder. We ended up calling LIBMTP_Send_File_From_File directly with the folder ID.

There was one more surprise: the default python3 on my Apple Silicon Mac was an x86 build, so it could not load the arm64 libmtp library.

“It works” was testing the wrong server

After moving the Bridge to the NAS, the watch showed a reply. It looked finished.

The metrics disagreed. The request had reached the old temporary Bridge on my Mac, because the watch had not loaded the new app yet. This is why I like boring server logs: the UI said success, but the logs told us which system actually succeeded.

We reinstalled the app and used a new launcher icon as a visible version marker. The next request appeared in the NAS metrics.

The result

The final path works without my Mac:

Measurement Result
Recording 5.68 seconds
Upload 21.6 KB Ogg Opus
Bridge round trip 5.8 seconds

That is one real request, not a benchmark. I have not measured long-term reliability, battery impact, or cellular performance. Spoken replies are not implemented yet, so answers appear as text.

How to reproduce it

You need:

  • A Garmin Forerunner 570
  • A Raspberry Pi with Bluetooth LE
  • A Docker host (the Pi can be this host)
  • The Muse app and a Gadget SDK token
  • A Mac with Java, the Connect IQ SDK, and the Forerunner 570 device package
  • A valid HTTPS endpoint, such as a Cloudflare Tunnel

1. Pair your phone with the Pi

git clone https://github.com/cczhong11/garmin-muse.git
cd garmin-muse
bash pi/setup.sh
bash pi/pair.sh

Paste the SDK token once. In the Muse app, turn on Settings > Devices > Developer mode, open Add Device, and choose MuseGadgetXXXXXX. The script should finish with paired: yes.

2. Start the Linux service

cd server
cp .env.example .env
cp .tunnel.env.example .tunnel.env
chmod 600 .env .tunnel.env

Set a random BRIDGE_SECRET, a UUID for BRIDGE_SESSION_ID, and your Cloudflare Tunnel token. Route your hostname to http://garmin-bridge:8792.

Then import the pairing and start the containers:

docker compose build
docker compose create
sudo tar -C "$HOME/muse-pair/state" -cf - identity.json pairing.json sdk_token |
  docker run --rm -i --network none --user 10001:10001 \
    -v garmin-muse_muse-gadget-state:/var/lib/musegadget \
    garmin-muse-gadget:7207ce6-net tar -C /var/lib/musegadget -xf -
docker compose up -d
docker compose logs -f muse-gadget

Wait for registered with the Muse.

3. Build the watch app

BRIDGE_URL=https://voice.example.com \
BRIDGE_SECRET=your-secret \
watch/build.sh fr57042mm

Use fr57047mm for the 47 mm model.

4. Install it on the watch

Set System > USB Mode to MTP, connect the watch, unlock it, and keep Android File Transfer closed.

brew install libmtp
watch/install.sh

Unplug the watch. If the icon does not update, restart it.

5. Talk to it

Open Muse Voice, press START, ask something, and press START again. Keep your phone nearby with Garmin Connect running.

Please use this only with your own Muse account and read the Gadget SDK Terms. They restrict selling or publicly listing devices, so sideload the app instead of publishing it to the Connect IQ Store.

What I learned

The fun part was not getting a watch to make an HTTP request. It was turning a vague idea into a series of small tests: can a device start a chat, can it see my memory, can the watch record usable audio, and can the whole path survive without my laptop?

Each answer changed the design. That is why I would build this kind of project in the same order again: test the scary assumption first, keep the device thin, and trust the logs more than the happy-looking UI.

comments powered by Disqus