I wanted to run my AI agents from my phone.

How I worked

The same habits run through all five setups. Each one shows up in a lesson below.

1. Use it every day. Every setup was my daily driver, not a demo. Real use is what turned up the failures, and it's why I have records of them.
2. Find the part that broke. When something went wrong, I asked which piece failed: the chat app carrying messages, the model, the agent using the tools, or the computer keeping track. It was rarely the model. That split became the design for Ophio.
3. Write it down before acting. Nado saves each message before it works on it, and keeps each answer until Telegram confirms it. A restart picks up where it left off, and the records show what happened.
4. Test the failure, not the happy path. A crash test has to crash at the worst moment. A Stop test needs an agent that keeps trying to act after the tap. A test that passes without reaching the failure proves nothing.
5. Measure, then choose. I timed encoders before picking a default, and I compared models blind, on the real work, before trusting a cheaper setup. What didn't earn its place came out.
6. Check the record, not my memory. For this page, I had Claude go through my records without changing them. It scanned 86,668 messages by keyword and went back to 64 of the originals to confirm the details. It worked the Stop numbers out again from each of the 21 saved trials and checked them against the saved summary. Nothing was rerun. These are fresh calculations from old records. Then it interviewed me, and the reasons on this page are my answers. I remembered why I made each choice. Claude found when, and how many times. I chose the story, and I stand behind it.

Five setups in six months

1. April

   OpenClaw on an old laptop

   I'd tried AI plenty of times before, and it always felt like a fancy autocomplete. OpenClaw looked like more than that, so I gave it a computer I could afford to lose: ChachaClaw, a laptop with a 2012 Intel chip and 16 GB of memory. I didn't think it would be good enough, or safe enough, for anything better. I had no goal. I was just curious.

   It blew me away and changed my mind completely. That's why I kept building. Even then, most of my time went into pairing, allowlists and permissions rather than actual work, which was my first hint about where the hard problems would be.

2. May

   Hermes

   OpenClaw was working fine. I moved to Hermes, an open-source agent, on May 25 because I wanted to see how other people were going about it. The migration moved 9 things, archived 4, skipped 31, and refused to overwrite 2 that conflicted. I liked that it didn't pretend everything carried over.

   I used Hermes hard for ten weeks: 3,309 sessions and 63,399 model calls. I also started changing it. I added a step that stripped stale context out of each request, and routing that picked a model by the kind of work. Hermes taught me a lot, including what I didn't want.

3. July

   A homemade bridge, and a new computer

   By July I wanted coding work done by Claude Code itself, with its own tools, instead of an agent steering it from outside. I built a small bridge from Telegram straight to Claude Code and, on July 26, switched it to Claude Code's native events.

   That same day I committed to Workhorse, a desktop with a Ryzen 9 9950X and 64 GB of memory. I already had most of the parts. I wanted my own server for my data and my own machine set up my way, and this got me both at once. The computer I already had became a home server running Proxmox. Workhorse became my new machine and the always-on home for the agents. I built it on August 2, then spent a day chasing black screens.

4. August

   Nado

   By August I'd worked out what bothered me about Hermes. It did too much. Whenever I told it how I wanted a project run, it saved that as a skill and used it on every project after. Its own records show it wrote 118 skills by itself and edited them 1,072 times. On July 26 I told it skills were mine to keep, not something to make at random. On July 29 it wrote 18 in a single day.

   All those skills bloated its context, and every lesson landed on every project. But each project needs its own touch. Some need a quick, bare-bones prototype. Others need to push the hardware to its limits. With every lesson in play at once, some projects spun their wheels for days, and others got far more complicated than they needed to be.

   I'd lost the fine control I need. Hermes put the vision in the agent's hands and left the software to me, and that felt backwards. AI makes most of the big technical calls as well as I do, often better. But software and websites are art. They need someone with a vision and strong opinions, and that's the part I want to keep.

   So I rewrote the whole thing in Rust and called it Nado. Over the next weeks it split into separate bots with separate jobs: Chanado to talk, Planado to plan, Claudenado to build. Hermes ran its last Telegram session on August 5. Nado received its first message on August 6, and it has had messages every day since.

5. September

   Ophio

   By September the models were so good that I had become the blocker. Agents finished work and waited for me to review it and ask for changes, and I couldn't be at my desk as often as they needed me. Projects sat waiting and my backlog grew. To keep something moving I'd start a new project, which only gave me one more project waiting on me.

   So late in September I started Ophio, a real Android app with a companion on the desktop. The phone stops being a chat window and becomes a remote control for the agents on my computer, so I can review work and ask for changes from a hike or a plane. You bring your own AI accounts and tools. The desktop keeps the record of what is actually running.

   My own setup had already freed me from the desk, and I wanted other people to have that too. Ophio isn't finished. For now I use it alongside Nado while I keep building it.

What broke, and what I changed

Every one of these started as a message I sent to one of my bots.

My part in it

I want to be clear about my part. I build with AI agents, mostly Claude Code, and they wrote most of the code in this story. Ophio's history alone has 1,546 commits from its first seven days, which tells you how fast agents write code, not how good it is. Making it good is the part I own: deciding what done means, testing it, and sending it back when it isn't. I didn't start from zero, either. I'd been writing code for years, and I'm decent with Python, though it isn't my strongest language.

Most AI tools still picture you at the computer, writing code alongside the model. That's where the model is strongest. It can hold a whole codebase at once and has read more than any of us ever will, so it finds bugs a person would miss. What it doesn't have is a life. I understand people, art and how things really go in the world, even if I've lost most of the details along the way. So I bring vision and direction: deciding what to build and how it should feel, choosing the right model for the job, noticing when something is off, and cutting what doesn't work. Finding something genuinely new is hard for an AI. It takes a lot of steering, and that's my part.

Steering sometimes means a hard no. When I asked for password sign-in on Ophio, I said the accounts couldn't leak. I meant safe from the outside world. The agent read it as walling everything off, my own agents included. It built hardware-backed approvals, a private desktop mode to keep my agents out, and much more, and none of it ever reached a working Accounts screen. An agent I run on my own computer can already read my credentials, so walling it off was pretend security. I vetoed it. On October 2 I reverted eight commits, about 22,000 lines, and pointed the security work at the real threat: someone from outside getting in.

What I'd do differently

I'd trust it sooner. In April I was so skeptical that I wasn't really trying to get the most out of it. I'd see a good result and still feel like it was a fluke. In fairness, the models were weaker then than they are now.

What this doesn't show

• It doesn't measure productivity or money saved. I don't have a fair before-and-after for either.
• A message isn't a task. The daily chart shows use, not output.
• The Stop and crash tests are lab runs from the past, on a virtual desktop with a browser standing in for the phone. I didn't rerun them for this page.
• The encoding numbers cover one part of the pipeline, measured on a machine doing other work.
• “Delivered” means Telegram accepted the answer. It doesn't mean I read it, and it doesn't prove nothing was ever lost.
• Ophio isn't finished, and I still use it alongside Nado. The phone screens in the film are its test build running on sample data.