A way of running an always-on Mac as a home for many AI coding agents. Each agent lives in its own tmux session. Each session maps to a single QWERTY key. You reach any of them with one keypress, from a desktop terminal or from ShellDrop on your phone. A Mac Mini is the canonical example here, but any always-on Mac or Linux box works the same way.
This is what greets you when you log in. One line per running agent, each on its own key:
Welcome operator.
q) claude-api
w) web-app
e) scraper
r) trading-bot
t) docs-site
> You keep one Mac running all the time. On it you run as many AI coding agents as you like: Claude Code, Codex, OpenClaw, Hermes, or any other agent. Each agent runs inside its own tmux session, focused on a single project. tmux keeps every session alive in parallel, detached, surviving disconnects and reboots of whatever device you connect from.
The mental model is one session per droplet. A droplet is one agent on one task. The Mac holds the droplets; you visit them.
The shell profile turns that list of sessions into a single-keypress launcher. When you log in over SSH, it greets you, prints every live session, and assigns each one a letter from the QWERTY layout. Press the letter, press Enter, and you are inside that session. The same menu shows up whether you connect from a desktop terminal or from ShellDrop on an iPhone or iPad.
The work lives on the Mac. The agents run on the always-on machine, so you can reach them from your desktop at the office, your laptop on the couch, or your phone on the train, and it is the same set of sessions every time. Pick up on the phone exactly where you left off on the desktop.
Because tmux holds the sessions and tmux outlives any single connection, a dropped connection is a non-event. The train goes through a tunnel, the laptop sleeps, the wifi drops, and the agent keeps working on the Mac the whole time. When you reconnect, the session is still there, mid-task, with its full scrollback intact. Nothing to restart, nothing lost.
And there is only ever one source of truth. Every device is a window onto the same live sessions on the same machine, so there are no copies to reconcile and no "which device was I on" guesswork. The state is wherever the work actually runs, and every screen you open is just looking at it.
You compound all of this with a memory system. Once the agents have a shared, persistent memory of your projects and client history, each session starts already knowing the context instead of relearning it every time. The work on the Mac stops being a set of isolated sessions and becomes one continuous body of knowledge that every agent draws on. Setting that up is its own walkthrough, and one is on the way.
If you already have a coding agent running on the Mac, it can do the whole setup for you. Copy the prompt below and paste it into your agent. It adds the login launcher to your shell config, turns on the tmux title emission ShellDrop reads, reloads both, and shows you how to create one session per project. The manual steps follow if you would rather do each one yourself.
Set up the ShellDrop Agent Operating System on this machine.
1. Add a login launcher to my shell config. macOS uses zsh, so this goes in ~/.zshrc. On every interactive login, when I am not already inside tmux, it should print "Welcome operator.", list every running tmux session, and map each session to a key from the QWERTY layout (q, w, e, r, t, y and so on) so I can attach by typing one letter and pressing Enter. Back up ~/.zshrc first, then add this exact block only if it is not already present:
if [[ -z "$TMUX" ]]; then
echo ""
echo "Welcome operator."
echo ""
if command -v tmux &>/dev/null && tmux ls &>/dev/null 2>&1; then
_keys=(q w e r t y u i o p a s d f g h j k l z x c v b n m)
_sessions=("${(@f)$(tmux ls -F '#S')}")
local i=1
for s in "${_sessions[@]}"; do
echo " ${_keys[$i]}) $s"
((i++))
done
echo ""
echo -n "> "
read _pick
if [[ -n "$_pick" ]]; then
_pick="${_pick:l}"
local idx=${_keys[(i)$_pick]}
if (( idx >= 1 && idx <= ${#_sessions[@]} )); then
tmux attach -t "${_sessions[$idx]}"
else
tmux attach -t "$_pick"
fi
fi
fi
fi
2. Make tmux emit each session name as the terminal title so the ShellDrop app can name its tabs. Back up ~/.tmux.conf first, then add these two lines if they are not already there:
set -g set-titles on
set -g set-titles-string '#S'
3. Reload both configs so the change is live: source ~/.zshrc, and if a tmux server is running, run tmux source-file ~/.tmux.conf.
4. Show me how to create one named tmux session per project with tmux new -s NAME, and remind me to run one agent per session.
Do not change anything else in my config.Enable Remote Login on the Mac (System Settings > General > Sharing > Remote Login), then connect over SSH. From a desktop, that is the usual ssh user@host. From a phone, open ShellDrop, add the Mac as a saved connection, and tap the card. Either way you land in the shell on the Mac Mini, and the login menu fires.
The menu lives in ~/.zshrc. The default macOS shell is zsh, so this is the file your login shell reads. On each login, while you are not already inside tmux, it prints a greeting, walks every running tmux session, and maps each one to a QWERTY key in order: q, w, e, r, t, y, u, i, o, p, a, s, d, f, and on through the keyboard. Then it reads a single key and attaches you to the matching session.
Paste this block into ~/.zshrc:
~/.zshrc# Show active sessions on login - QWERTY keys to attach (skip inside tmux)
if [[ -z "$TMUX" ]]; then
echo ""
echo "Welcome operator."
echo ""
if command -v tmux &>/dev/null && tmux ls &>/dev/null 2>&1; then
_keys=(q w e r t y u i o p a s d f g h j k l z x c v b n m)
_sessions=("${(@f)$(tmux ls -F '#S')}")
local i=1
for s in "${_sessions[@]}"; do
echo " ${_keys[$i]}) $s"
((i++))
done
echo ""
echo -n "> "
read _pick
if [[ -n "$_pick" ]]; then
_pick="${_pick:l}"
local idx=${_keys[(i)$_pick]}
if (( idx >= 1 && idx <= ${#_sessions[@]} )); then
tmux attach -t "${_sessions[$idx]}"
else
tmux attach -t "$_pick"
fi
fi
fi
fiThis is zsh-specific. The ${_pick:l} lowercasing and the ${(@f)...} array split are zsh features, so keep the block in ~/.zshrc rather than .bashrc. The if [[ -z "$TMUX" ]] guard means the menu only runs on a fresh login. It stays quiet when you open a new pane inside a session that is already attached.
With five sessions running, a login looks like this. The session names below are illustrative:
Welcome operator.
q) claude-api
w) web-app
e) scraper
r) trading-bot
t) docs-site
> The greeting, then one line per live session, each prefixed with the key that attaches it. The cursor waits at the prompt for a single key.
Press q then Enter and you drop straight into the claude-api session. The letter next to each session is the whole interface.
If you type a key that is not in the list, the block falls through to tmux attach -t on whatever you typed, so attaching by full name still works when you want it.
Every tmux session holds one agent working on one project. That is the droplet model: a focused worker, kept alive on the Mac, ready whenever you visit it. Because tmux runs the sessions and tmux outlives your SSH connection, an agent keeps working after you disconnect. Close your laptop or reboot the client you connected from, and the session is still there, mid-task, when you come back.
ShellDrop has a Sync Tmux-tabs feature that names each tab after the session it is showing. For that to work, the Mac has to emit each session's name as the terminal title. tmux can do this with two lines in ~/.tmux.conf:
~/.tmux.conf# emit the tmux session name as the terminal title (OSC 2) so ShellDrop's
# "Sync Tmux-tabs" can pull it. Applies to every session on this host.
set -g set-titles on
set -g set-titles-string '#S'With these set, every session announces its name through the standard terminal-title escape sequence. ShellDrop reads it and labels the tab, so a tab attached to scraper reads as scraper rather than a generic shell name.
You spin up a named session per project, then start the agent inside it:
create a sessiontmux new -s claude-api
# inside: cd ~/projects/claude-api && claude --dangerously-skip-permissions (permissionless mode)
# detach with ctrl-b d and the session keeps runningThe name you give with -s is what shows up in the login menu and the tab title. Pick names that read well as a one-line list. After you detach, the session stays running on the Mac, and it appears in the QWERTY menu the next time you log in.
Run the agent in permissionless mode. On an always-on host you want the agent to keep working without pausing for approval on every edit or command. Start Claude Code with claude --dangerously-skip-permissions, its permissionless mode, so a session does not stall waiting on a confirmation you are not there to give.
Permissionless mode hands the agent real autonomy, so it is worth learning where that autonomy sits before you lean on it. Give it low-stakes work first, watch how it handles things, and widen what you hand off as you go. Knowing what your agent can and cannot be trusted to do on its own is part of the setup, and it is what makes hands-off operation work.
The point of emitting titles and keeping sessions alive is that the whole thing comes with you. Open ShellDrop, connect to the Mac Mini, and you get the same Welcome operator menu. Press q, w, or e to jump into a session, exactly as you would from a desktop.
That is the full loop. The Mac holds the agents, the shell profile turns them into a keyed list, tmux keeps them alive, and ShellDrop puts that same list in your pocket.