Start the Work, Then Walk Away
I have two computers. One is a quiet workhorse with more power than sense, and one is older but sits under a big beautiful monitor where I actually like to think. For a while I treated them as a choice: work on the powerful one, or work at the comfortable one. And then a small, stupid friction started to bother me. I’d kick off a long agentic build — the kind that runs for an hour, churning through a stack of tickets — and then I’d just… sit there. Tethered. Because the moment I closed the laptop or drove off to run an errand, the work went with me.
That’s a dumb thing to be trapped by. The machine doesn’t need me to watch it work. So why did leaving kill the work?
The thing I’d quietly conflated
It took me longer than it should have to see what I’d tangled together. I’d fused three ideas that have no business being fused: starting the work, staying connected to it, and keeping the machine awake. In my head they were one act. Start = stay = babysit. But they’re three separate things, and each has its own clean answer.
Starting the work is a command. Staying connected is a network question. Keeping the machine awake is a power setting. Once you pull them apart, “leave the powerful computer running on its own while I go live my life” stops being a wish and becomes a checklist.
Three pieces, each doing one job
A private wire between the two machines. I put both computers on a Tailscale network — a little private mesh where my machines can see each other by name, from anywhere, without exposing anything to the open internet. From the couch computer I can now reach the workhorse as if it were sitting on the same desk: ssh matt@mop. No ports poked open to the world, no dynamic-DNS nonsense. Just a quiet, encrypted hallway between two machines I own. This is the part that makes it mine and only mine — the workhorse isn’t a server on the internet, it’s a room only I have a key to.
A session that outlives the connection. This is the piece I’d been missing, and it’s the whole trick. When you SSH into a machine and run something, that something is usually a child of your connection — the connection dies, the work dies with it. A tool called tmux breaks that leash. You start a session on the workhorse, launch the job inside it, and then detach — you step out of the room and the work keeps happening in there whether you’re watching or not. Close the laptop, drive to the store, and the job doesn’t even notice you left. Later I can reconnect from the old Mac, or honestly from my phone on cellular, and reattach to the exact same session, mid-stream, like I never walked away.
That’s the sentence I’d underline for anyone building something like this: the session should outlive the connection. The connection is a window you look through, not the thing holding the work up.
A machine that refuses to nap. The last piece is almost embarrassingly mundane, and it’s the one that bites everyone. Computers sleep. A laptop especially wants to sleep the instant you close it, and a sleeping machine does no work. So the job gets wrapped in caffeinate, a macOS command that holds the machine awake for exactly as long as the task is running and then lets it rest again. Not “never sleep, forever” — just “stay up until this is done.” The awake-ness has the same lifetime as the work.
Wiring it into one verb
I could stop there — SSH in, start tmux, remember the caffeinate incantation, cd into the right folder, launch the agent. But I’ve learned that if a good habit requires me to remember four steps in the right order, I will eventually do it wrong at 11pm and blame the tools. So I collapsed the whole dance into a single command I can run the second I connect:
agent-run northless
That one line finds the project, starts a fresh detached session, wraps it in caffeinate so the machine stays up, and drops an agent into the right folder — already awake, already running, already independent of me. Run the same command again later and it doesn’t start a second copy; it just walks me back into the live one so I can peek. Start it, close the lid, go. Come back, glance, leave again.
The interesting move here is the same one I keep making everywhere lately: build the capability once, at the level of the tool, so every project gets it for free. I don’t set this up per repo. The wiring lives on the machine. Any project I point it at inherits the whole “start it and walk away” behavior without me thinking about it again.
What I’m being careful about
Two honest caveats, because “leave a powerful machine running by itself” deserves them.
Staying alive isn’t the same as making progress. tmux guarantees the process keeps running; it does not guarantee the work moves forward. If the agent hits a fork it can’t resolve and stops to ask me a question, it will sit there, patient and idle, until I reattach and answer. This setup is a gift for autonomous, well-scoped runs — a batch of tickets, a long build, a loop that knows how to finish. It does nothing for a task that needs a human in the middle. So the real discipline isn’t the plumbing; it’s scoping the work so it can run without me before I walk out the door.
A machine that runs without you is a machine you’re trusting. The reason I’m comfortable leaving the workhorse chugging on its own is that it’s not reachable by anyone but me — it lives behind that private Tailscale wire, not on the open internet. The convenience and the safety come from the same decision. If I’d gotten the “reach it from anywhere” part by opening my machine to the whole world instead, this would be a story about a security incident, not a productivity trick.
But with those two things minded — scope it to run alone, and keep the door private — the result is genuinely freeing. I start the heavy work from the comfortable chair, close the lid, and go do the errands. The workhorse keeps its head down and grinds. And the best measure of the whole setup is that, most of the time, I forget it’s even running.
Onward.