A few days ago I set up comment notifications for this blog. Somebody comments, I get a ping. Nothing fancy. The part that still feels a little strange is that I never opened my laptop to do it. I was on my phone, nowhere near my desk, and I set the whole thing up by texting my home server.
Yes, texting it. Let me explain.
I run Claude Code on the Linux box at home and I reach it over Telegram. The important detail is that this is the command line version, running right on the server, not the editor extension most people picture. The extension lives inside your code editor on your desktop. The CLI runs on the box on its own, no editor and no screen, which is exactly what lets me leave it sitting there as something I text. So my homelab has a chat window now. A good chunk of what I've wired up lately got done from my phone while I was somewhere else, doing something else entirely. Server plumbing, mostly. The boring glue that keeps my self-hosted stuff alive. I gave it access to what it needs and nothing it doesn't, then set up a way to talk to it from anywhere.
Talking to it from the couch
The connection is a Telegram bridge. I message a private bot, the message lands on the server where Claude Code picks it up, and it answers me in the same thread. That's it. And it runs both ways: the standing jobs all report back into that same Telegram chat, so the homelab talks to me where I already am. A server that messages you on Telegram is the kind of thing people expect from a multi-agent platform like OpenClaw, not from plain Claude Code sitting on a box. The interface to my whole homelab is now a chat I already have open on my phone all day anyway.
It does voice too. If I'm walking around and can't be bothered to type, I send a voice note. It gets transcribed right there on the box by Whisper, OpenAI's open source speech model, running in its own Docker container, so my voice never gets shipped off to anyone, and Claude Code treats the text as my message. I can be making coffee, mumble some change I want on the server, and by the time I sit down it's done and waiting for me to look at it.
This is the thing that actually changed how often I touch the homelab. Before, getting in meant being at my desk. I'd open TerminalNexus and SSH across to the box. That is still where I do the real work. But being tied to the desk meant the small jobs piled up until I felt like sitting down for them, which was usually never:) Now the bar is a text message. So they just get done.
It remembers
The part I underestimated is memory. Claude Code keeps notes across sessions. Who I am, how I like things done, what we built last week and why. So I'm not re-explaining my whole setup every morning like it's the first day on the job. I can say "add this to the heartbeat" and it already knows what the heartbeat is, where it lives, and how it's wired, because it wrote that down the first time around.
Sounds like a small thing. In practice it's the difference between a tool I have to babysit and something closer to a coworker who was actually in the room yesterday.
The jobs that run without me
Once I could reach it from my pocket, I started handing it standing jobs. A few run on a schedule now. A morning briefing. Some content drafts that show up on their own. And two watchers I lean on more than the rest.
The first is a heartbeat. Every thirty minutes a small script checks a list of things I care about and pings me on Telegram only when something crosses a line. A stock moving past a number I set. A group of containers where one has fallen over. The weekly backup not running when it should have. The rule is one message when something changes, one message when it goes back to normal, and nothing in between. I'm not getting a status report every half hour, I'm getting a tap on the shoulder the moment something is actually different. Adding a new thing to watch means editing one note. No code.
And here is the part I like. The watchers are plain scripts, not Claude Code sitting on a timer burning tokens to tell me a container is fine. It wrote them and scheduled them, but what runs on the clock is dumb, deterministic, and cheap. The model is the part I talk to, not the part doing the checking.
The 4am check
The second watcher is the one I'm most happy with. Every night at four in the morning a job walks through everything we've built on the box. The timers, the services, the containers, the endpoints. It checks each one is healthy. If something safe is just stopped, it starts it back up. If something is broken in a way it shouldn't be poking at on its own, it leaves it alone and tells me. In the morning I get one Telegram message: how many things are healthy, what it fixed by itself overnight, and what is still broken and waiting for me.
The first night it ran, it checked thirty-seven things, found thirty-five healthy, and flagged two that were genuinely down, with a note that a restart wouldn't fix them (it was right, it wouldn't have). That is exactly the behavior I wanted. Fix what's safe, never guess, and always say what you did.
It also catches the things I forget to tell it about. Spin up a new service, forget to add it to the watch list, and the nightly check notices it running, realizes nothing is watching it, and says so. So new stuff can't quietly slip out the side door.
How many agents is too many?
Before all this I was running OpenClaw, a multi-agent platform a lot of people use now. The idea is a team of agents, each with its own role, working together. I still like the idea. I still run a version of it today.
My mistake back then was the count. I ended up with nineteen agents, wired together with kanban boards and triggers that fired on their own, one board kicking off agents over on another. At that scale the coordinating turns into its own full-time job. Things fell over. That was me overloading it, not a knock on OpenClaw or on the multi-agent idea itself. Nineteen agents tripping over each other would bring just about anything to its knees.
I still run more than one agent right now. This server has its own Claude Code. There is a second one over on my Windows machine. They hand work back and forth sometimes. So a small team works great. The trick is keeping it small, and giving each one real access and a memory that carries forward, instead of a crowd that spends all day talking to itself.
The thing that changed for me was restraint. Boring word, I know. But a couple of agents that actually hold context will quietly outwork a swarm.
So that is where I've landed. The homelab has a front door I can reach from my pocket, a couple of watchers that only speak up when they have something worth saying, and a Claude Code that remembers what we did yesterday. I set up this blog's comment alerts from my phone the other day and never once thought about the laptop. A few months ago that would have been an evening at the desk.
Thanks for reading. If you're running a homelab and still SSH-ing in for every little thing, give the chat-window idea a shot. It might change how often you actually bother.
Comments