Run an AI SEO Agency from Your Phone: Grok Bot + Tailscale Dual-Machine Architecture

Run a two-machine SEO agency from your phone via Grok Bot: Tailscale private net, passwordless SSH, driver-neutral runbook, run locks, and approval hooks

Who

Technical operators who need to manage multi-machine workflows from a phone

You get

Grok Bot as front door, scheduling mac (business) and x1 (client work) via Tailscale SSH, with dual drivers sharing runbook and locks

You need

Grok Bot

Steps

1. Build private network with Tailscale and configure SSH

   Install Tailscale on Grok Bot's cloud computer and join your tailnet; do the same on mac and x1. Generate a dedicated SSH key pair for the bot, add the public key to ~/.ssh/authorized_keys on both mac and x1. Create ~/.ssh/config on the bot's computer with short names (mac / shed). Test ssh mac and ssh shed should log in without password. For a fresh tailnet, consider using tags to restrict the bot to SSH-only access to your machines.

   Execution prompt · Source text。Grok Bot cloud computer terminal; tailscale status should list bot, mac, x1 after run

   Copy prompt

   # on grok bot's cloud computer
   curl -fsSL https://tailscale.com/install.sh | sh
   
   # no /dev/net/tun on the box? run the daemon in userspace mode
   # sudo tailscaled --tun=userspace-networking &
   
   # join the tailnet. it prints a login url. approve it from your phone.
   sudo tailscale up --hostname=<bot-box>
   
   tailscale status    # your mac and x1 should be listed by name

   Execution prompt · Source text。Terminal on mac and x1; add bot public key to authorized_keys

   Copy prompt

   # on the mac and on the x1
   # the bot's public key only. one line per key, easy to revoke.
   echo 'ssh-ed25519 AAAA<bot-public-key> grokbot' >> ~/.ssh/authorized_keys

   Execution prompt · Source text。~/.ssh/config on Grok Bot's cloud computer

   Copy prompt

   # ~/.ssh/config on grok bot's computer
   Host mac
       HostName <mac-name>.<your-tailnet>.ts.net
       User <user>
   
   Host shed
       HostName <x1-name>.<your-tailnet>.ts.net
       User <user>
       Port <ssh-port>

   Setup guidance · Source text。Tailscale ACL console (optional, author recommends for fresh tailnets)

   Copy prompt

   {
     "tagOwners": {
       "tag:agent": ["autogroup:admin"],
       "tag:home":  ["autogroup:admin"]
     },
     "grants": [
       { "src": ["tag:agent"], "dst": ["tag:home"], "ip": ["tcp:<ssh-port>"] }
     ]
   }

2. Split roles: mac for business, x1 for client work

   mac handles GTM, finance, proposals, and business-side work; also runs Hermes (if used) and Prime Agent business chats. All keys and billing credentials stay on mac. x1 (the AI shed) handles all client execution, with one dedicated Prime Agent chat and folder per client; every job ends with a written receipt. Rule: never run agent work on the machine you're sitting at—mac orchestrates, x1 executes.

3. Configure main router, HANDOFF template, and SSH dispatch

   The main bot acts as router: all phone commands land here first, then get routed to owners. Specialist bots each own one lane; HANDOFF messages use a fixed shape so the receiving bot can start with nothing else. For work on machines, the router sends a brief to the owning chat over SSH, then waits for receipt. The dispatch script must implement: refusing jobs when the chat is busy or already holds a claim, and rejecting duplicate briefs for the same job. Each chat owns one job at a time.

   Execution prompt · Source text。HANDOFF message format from Grok Bot main router to specialist bot

   Copy prompt

   HANDOFF  <id>
   from:    main
   to:      <specialist>
   task:    list this week's inbox threads that need a decision from me
   context: /workspace/<project>/rules.md and /workspace/<project>/clients.md
   done =   one line per thread with the link and the decision needed, saved to
            /workspace/<project>/decisions/<date>.md
   limits:  read only. no replies, no labels, no archiving.
   return:  one line to main: verified | needs yes | blocked: <cause>

   Execution prompt · Source text。Grok Bot cloud computer terminal; SSH brief to Prime Agent on shed and read receipt

   Copy prompt

   # from grok bot's computer: brief the client chat on the shed
   ssh shed 'prime-agent send <session-id> "$(cat ~/<workspace>/Runtime/briefs/<occ-id>.md)"'
   
   # later: read the receipt the chat wrote when it finished
   ssh shed 'cat ~/<workspace>/Runtime/receipts/<occ-id>.md'

4. Build driver-neutral runbook, run locks, and scheduled routines

   Place scripts at identical paths on both machines so any driver (Hermes/Grok Bot) calls the same ops-* commands. Write the runbook in markdown, using 'the driver' everywhere a name would appear. Before each routine, use ops-lock to create a daily lock file; if it exists, the second driver prints SKIP and stops. Routines (e.g., morning brief) are saved prompts with strict schedules and output formats; cron on mac triggers the same pre-run lock when Hermes holds the clock.

   Execution prompt · Source text。Grok Bot saved routine prompt, or runbook entry read before cron trigger

   Copy prompt

   ROUTINE  morning brief
   when:    every day 06:45 local
   first:   take the lock. ops-lock R1. if it prints SKIP, stop.
   read:    the evidence pack in Runtime/, today's calendar, inbox labels
   write:   one message, 250 words max. drop empty sections.
            money. client deadlines. approvals waiting. today's calendar.
            inbox items that need me.
   rule:    every money or client line carries its source path.
   never:   send, publish or change anything.

   Execution prompt · Source text。ops-lock script on mac and x1; place at ~/workspace/ops/bin/ or identical path

   Copy prompt

   #!/usr/bin/env bash
   # ops-lock <routine> [slot]: one run per routine per day (or per slot)
   set -euo pipefail
   routine="$1"; slot="${2:-}"
   day="$(date +%F)"
   lock="$HOME/<workspace>/Runtime/locks/${routine}-${day}${slot:+-$slot}.lock"
   mkdir -p "$(dirname "$lock")"
   
   # noclobber makes the create atomic: the first driver wins
   if ( set -o noclobber
        printf '{"routine":"%s","driver":"%s","host":"%s","started":"%s"}\n' \
          "$routine" "${OPS_DRIVER:-unknown}" "$(hostname)" "$(date -Iseconds)" > "$lock"
      ) 2>/dev/null; then
     echo "LOCKED $lock"
   else
     echo "SKIP: $routine already run or running ($(cat "$lock"))"
     exit 0
   fi

   Execution prompt · Source text。Runbook markdown entry for R2; describes dispatch scheduling logic

   Copy prompt

   ## R2 due-work router
   when:     08:30 and 13:30
   driver:   the scheduled driver (see 3a). anyone may run it on demand.
   steps:
     1. ops-lock R2 <HHMM>. SKIP means another driver has it. stop.
     2. read Runtime/due.md. pick items whose owner chat is idle.
     3. ops-dispatch <chat> <occ-id> <brief-file>
     4. log the occurrence id in the work log.
   done:     every due item is dispatched, or listed as blocked with one cause.
   gate:     none. dispatch is internal. sends and releases need a yes.
   
   ## 3a who holds the clock
   scheduled driver: <hermes | grokbot>
   on-demand:        either, same scripts, same locks.

   Execution prompt · Source text。mac crontab example (when Hermes holds the clock)

   Copy prompt

   # illustrative crontab line on the mac
   45 6 * * *  OPS_DRIVER=hermes ~/<workspace>/ops/bin/ops-r1.sh >> ~/<workspace>/logs/r1.log 2>&1

5. Set up approval hook and security boundaries

   Security boundaries rest on network, keys, and approval hook: keys live on the machine that uses them, nothing sensitive on the shared cloud computer; the bot accesses via dedicated SSH key on a private network with no public ports; a pre-tool hook on mac blocks send/publish/deploy/delete until you explicitly reply yes in that chat. Grok Bot's cloud computer and bot screens are not separate security boundaries (per official docs), so all writes are restricted to an inbox folder and append-only dump log; everything else is read-only.

   Execution prompt · Source text。pre_tool_call hook implementation on mac; integrate with your agent framework

   Copy prompt

   # pre_tool_call hook (illustrative)
   GATED = ("send", "publish", "deploy", "delete")
   
   def pre_tool_call(tool: str, args: dict, ctx) -> dict:
       if any(word in tool for word in GATED):
           # only my own message in this chat counts as a yes
           if not ctx.approved_by_owner(tool, args, channel=ctx.channel):
               return {"allow": False, "reason": f"needs a yes: {tool}"}
       return {"allow": True}

No prompt needed — just follow the steps.