I Run My Company From My Watch Now. Here's How to Build It.

i run my company from my watch now.

not a demo. not a someday thing. this morning, one sentence spoken into my watch moved a meeting, messaged a colleague on whatsapp, merged a pull request, and checked one of my backends was healthy. my laptop never opened.

here's the clip that kicked it off:

that's the original post on LinkedIn if you want to react or steal the idea.

the one idea worth taking

the phone is the computer. the agent lives on it and never sleeps. the watch is just a microphone. and the work happens in the background, so my wrist never waits for it. i speak one line, get an instant "got it," and a minute later my phone tells me it's all done. no app, no typing, no dashboard. voice is the entire interface. that flip, from screens to a sentence, is the whole thing.

the rest of this post is the beginner's guide to building it yourself. it works the same whether you run Hermes or OpenClaw as your agent. nothing here is exotic.

how it actually works

five hops, that's the whole system:

Apple Watch
   → Apple Shortcut (dictate text)
      → Cloudflare Tunnel (public https, no open ports)
         → tiny Flask bridge (on the phone)
            → your agent (Hermes / OpenClaw)
               → Telegram (the answer comes back here)

the watch talks to a Shortcut. the Shortcut posts your dictated text to a public URL. a Cloudflare tunnel forwards that to a small Flask bridge running on the phone. the bridge hands the task to your agent, and, this is the important bit, replies to the watch instantly while the agent keeps working. when the agent finishes, the result gets pushed to Telegram.

what you need

• an android phone running Termux with Hermes or OpenClaw already set up (if you haven't, start with my Hermes on Termux writeup)
• your agent exposing a local HTTP API (Hermes ships an OpenAI-compatible server)
• a free Cloudflare account + a domain, for the tunnel
• a Telegram bot token + your chat id, for the replies
• an iphone / apple watch with the Shortcuts app

step 1: expose your agent

your agent's API only listens on the phone (127.0.0.1). you need it reachable from the watch without opening router ports or leaking your IP. a Cloudflare tunnel does exactly that.

point a hostname at the two local ports, the agent API and the bridge you'll build in step 2:

# ~/.cloudflared/config.yml
tunnel: <your-tunnel-id>
credentials-file: /path/to/<your-tunnel-id>.json
 
ingress:
  - hostname: agent.yourdomain.com
    path: /watch*
    service: http://127.0.0.1:8765   # the Flask bridge (step 2)
  - hostname: agent.yourdomain.com
    service: http://127.0.0.1:8642   # your agent's API
  - service: http_status:404

now https://agent.yourdomain.com reaches your phone, encrypted, from anywhere.

step 2: the async bridge

here's the trick that makes it feel instant.

a watch should never wait 30 seconds for an AI task. so you don't call the agent directly. you put a tiny bridge in front of it that does two things: reply to the watch immediately, then run the real task on a background thread and push the result to Telegram when it's done.

it's about 30 lines of Flask:

# watch-api/server.py — the async bridge (trimmed)
from flask import Flask, request, jsonify
import os, uuid, threading, requests
 
app = Flask(__name__)
AGENT_API = "http://127.0.0.1:8642/v1/chat/completions"  # your local agent
API_KEY   = os.environ["AGENT_API_KEY"]
TG_TOKEN  = os.environ["TELEGRAM_BOT_TOKEN"]
TG_CHAT   = os.environ["TELEGRAM_CHAT_ID"]
 
def run_task(text):
    r = requests.post(
        AGENT_API,
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"model": "hermes-agent",
              "messages": [{"role": "user", "content": text}]},
        timeout=300,
    )
    answer = r.json()["choices"][0]["message"]["content"]
    requests.post(
        f"https://api.telegram.org/bot{TG_TOKEN}/sendMessage",
        json={"chat_id": TG_CHAT, "text": answer},
        timeout=10,
    )
 
@app.post("/watch")
def watch():
    text = (request.get_json(force=True) or {}).get("text", "").strip()
    if not text:
        return jsonify(error="missing text"), 400
    threading.Thread(target=run_task, args=(text,), daemon=True).start()
    return jsonify(accepted=True, id=uuid.uuid4().hex[:8])  # instant ACK

the watch gets {"accepted": true} in about a second. the agent takes as long as it takes. you never feel it.

step 3: the apple shortcut

this is the part you speak to. open the Shortcuts app and build three actions:

1. Dictate Text — captures your voice as text.
2. Get Contents of URL — POST to https://agent.yourdomain.com/watch, Request Body: JSON, one field text set to the dictated text. add an Authorization: Bearer <your-key> header.
3. Show Notification — "sent to your agent."

name it something you can say out loud, then add it to your watch face or trigger it with "Hey Siri, run agent." now raising your wrist and talking is the entire workflow.

step 4: getting the answer back

you already wired this in step 2. when the agent finishes, the bridge pushes the result to Telegram, so the answer lands on your phone (and your watch, via the Telegram notification) a minute later. no polling, no refreshing. Telegram is the simplest reliable channel here, ntfy or a push service work just as well.

keeping it alive on android

android aggressively suspends background apps, so two things keep this running 24/7:

termux-wake-lock                                    # stop the OS killing Termux
pm2 start server.py --interpreter python --name watch-api
pm2 start cloudflared --name tunnel -- tunnel run <your-tunnel-id>
pm2 save                                            # survive reboots

termux-wake-lock stops android from freezing the process, and PM2 restarts everything after a reboot. that's what turns a phone in a drawer into an always-on agent you can reach from your wrist.

that's the whole build. an old android phone, a runtime that fits it, a tunnel, thirty lines of Flask, and a Shortcut. the hard part was never the code, it was realizing the phone was already a good enough computer and the watch was already a good enough remote.

if you want the runtime side of this, how i run the agent swarm that answers these commands, read Hermes on Termux.

the interface isn't a screen anymore. it's a sentence.

stay building.