I get my best ideas for things to remember while I’m in the middle of something else. I’ll be deep in a refactor and think “I should check whether that upstream fix landed next week,” and the only way to capture it is to stop, switch to my phone or a calendar, type it out, and climb back into what I was doing. The context switch is small and it happens constantly, and small constant friction is exactly the kind I want to remove.

I already have an assistant that’s good at this. Hermes is a personal agent on a small VM that I talk to over Telegram. It sets reminders and runs scheduled jobs. The problem was that the agents I spend my day with, Claude Code and Codex in the terminal, had no way to reach it. So I built a bridge, and the more interesting half of the story is how Nix makes that bridge something I never have to think about again.

The bridge

Hermes already knew how to schedule work. It just needed a door other programs could knock on. Most agent frameworks can expose an HTTP API, so I turned Hermes’ on, put a bearer key in front of it, and limited it to my Tailscale network. Reachable from my laptops, invisible to the public internet.

Then I gave Claude Code a skill: when I ask for a reminder or a scheduled task, send a plain-English instruction to that API. I don’t teach the coding agent anything about cron syntax or job formats. I hand Hermes a sentence and it works out the rest with its own scheduling tool.

So now I type “remind me in two weeks to check on the new setup” into the same terminal I’m already working in. Claude passes the sentence along, Hermes makes the job, and two weeks later my phone buzzes. One agent doing the part it’s good at, handing the rest to an agent that’s good at something else.

The reminders don’t have to be dumb timers. The same day I built this, I had a few temporary workarounds in my config that I wanted to remove once the upstream fixes shipped. Instead of a reminder that just nags me on a date, I had Claude set up a recurring job that checks whether each fix has actually landed and only messages me when one is ready to pull out. A reminder that does the legwork before deciding to bother me.

Why Nix is doing the heavy lifting

This is the part that makes it more than a one-off script. Every piece of that bridge is declared in my Nix config: turning on the API, the firewall rule that keeps it on the tailnet, the encrypted secret for the bearer key, and the skill itself. None of it is something I set up by hand on one machine and hope I remember to repeat on the next.

The skill lives in my config as a directory that gets discovered automatically and handed to both Claude Code and Codex. When I push it to my repo, every machine I own picks it up and rebuilds itself. The laptop I set up next month gets the same skill, wired to the same assistant, without me touching it. The config is the setup, and the config is the documentation.

That matters more than it sounds. The failure mode for this kind of personal automation is that it works great on the machine you built it on and quietly rots everywhere else. You tweak a dotfile here, forget to copy it there, and six months later you can’t remember how any of it was wired. Describing it in Nix instead means the wiring is one source of truth that applies identically across every machine. Rather than configuring each host by hand, I describe what I want once and let them all converge on it.

Why you’d want this, and what I expect to learn

The immediate payoff is the friction that disappears, but the part I’m actually curious about is the pattern underneath. This is one specialized agent calling another in plain language, and it works because each side is good at a different thing. The coding agent is where my attention already is; the assistant is where scheduling and notifications already live. Letting them talk turns two separate tools into something closer to a team.

I don’t know yet how far that goes, which is most of why I find it interesting. Does plain natural language stay good enough as the interface between agents, or do I start wanting more structure once they hand each other more than reminders? Does this stay a one-way bridge, or do I end up with the assistant delegating back into the coding tools? How much does erasing that little context switch actually change how often I capture a thought, versus letting it slip? I’ll have a better sense after a few weeks of living with it.

If you want to try the same thing, the shape is small: expose your assistant’s API, lock it to a private network, and teach your coding tool to send it natural language. The scheduling smarts already exist on the assistant side. You’re just giving it a sentence, and if you describe the whole thing declaratively, giving it to every machine you own at once.

I also gave these agents a shared memory, which turned out to be the bigger project. That’s the next post.