Putting life on autopilot

Everyone has a lot on their plate. My life isn't any different. I've the stuff I must do, from paying bills to helping my parents shop online, to the stuff I'd love to be doing, like learning (including through this project) and spending time with my friends.

Over the weekend, I took on a challenge: how much of my to-do list could I actually automate?

The premise was simple. If I could get an AI agent to take on most of the work I don't want to be doing, including some “nice” things that still involve work such as planning a trip, I'd have more time for the things I actually want.

I had too many AI tools. I used Codex on my Mac, connected to my Notion and local filesystem, occasionally Claude on the cloud, and I had OpenClaw agents running on a server, each responsible for a different area of my life.

While it looked like a personal AI system, it really wasn't. It was a collection of tools with me acting as the routing layer.

Every time something needed to happen, I had to choose the right agent and make sure it had the right context. This became the problem, as the systems knew different versions of me: information was dispersed across Notion, my filesystem, and the independent memories of the agents.

This meant that asking one of them about my career could lead to totally different answers. So before automating my life, I needed to actually remove myself from the job of connecting it all together.

First, I killed most of my agents

I was quite determined about this.

My first step was creating a single source of truth about me. This isn't a new idea (see Karpathy's llm-wiki repo), but it meant killing my Notion and my existing OpenClaw agents in the process.

Everything worth keeping was moved into appropriately structured files in my local filesystem.

Across three separate versions of this “truth,” I was able to kill what had been superseded, establishing my wiki as what things actually are, with my filesystem providing the supporting evidence. I later connected WhatsApp with read-only access so the system could retrieve additional context when needed.

That solved one problem: context.

However, I still had another one – all the different interfaces through which I was interacting with my agents. While I appreciate that ADHD doesn't help, I was overwhelmed by the sprawl of tools I was using, which actually led to some of my previously most-used agents simply being left at bay.

So I decided I would have one front door, with Codex becoming my conversational and automation runtime, and Jeeves (my favorite agent) being its user-facing identity.

I didn't completely get rid of my other agents, however. Given specialized agents tend to perform better than generalists, I just de-anthropomorphized them instead: they lost their individual personalities (e.g., rough) and their names (e.g., Arnold), and were downgraded to specialized workers in the background whose skills and tools Jeeves could call whenever needed, like checking what's suitable for my gut on a restaurant menu.

From my perspective, though, there was now only Jeeves.

Working out what Jeeves could actually do without me

This turned out to be the more interesting problem; take a task like buying a suit for a friend's wedding in a month's time.

Normally, I'd look at my to-do list, decide if now was the right time to tackle that task, and start gathering context.

I'd be answering questions like what color should I go for? What's my size? How much does a good suit cost? Where should I buy one? When do I actually need it?

I won't know all of this when I first decide “I need a suit,” so I'd open ChatGPT or Claude, explain the wedding, do some research, compare options, learn a little about suits and eventually book a trial.

The interesting question was: how much of that process actually requires me? I ended up splitting my tasks into three tiers:

1. Fully automatable. The information is known and the agent can complete the task. Canceling a subscription, for example, including saying No to all the retention tactics the seller tries to use.
2. Partially automatable. This is where most of my tasks fall. The agent can do most of the work, but at some point I need to make a decision. Jeeves can research suits based on agreed criteria, but I still want to decide which suit I'm buying.
3. Non-automatable. I simply need to do it myself. Attending the suit trial is an obvious example.

This gave me a much better definition of what I actually wanted from automation. The goal wasn't necessarily "run my life", but "do everything you can without me, stopping exactly where you need my judgment."

Managing the agent's work

I needed a way to establish with Jeeves not just what I wanted, but what it was authorized to do, so I used the same project management tool we have at work – Linear.

I built a Codex skill that Jeeves calls whenever preparing a Linear issue/ticket – it helps determine a clear outcome, scope, exclusions, relevant context, and definition of success for every task.

Importantly, it also pushes for the minimum context necessary to be confirmed upfront, leveraging the wiki to get the general terms and then find the supporting documents in the filesystem.

Every time, I just have to review it, align on scope, and boom, the ticket enters the pipeline.

This is where the automation starts – if the next actor on a task is the agent, a scheduled heartbeat that runs every 30 mins catches it and moves it into active work. If the next step belongs to me, it goes into In Review and waits for my decision, credentials, identity verification, or some physical action.

Back to the suit example, the Linear ticket gave Jeeves the criteria it needed. He then went on to do the research and brought me three options. I just got a notification, picked up the task, had some back-and-forth with it because I wanted to understand what actually makes a suit good, and chose where I wanted to book a trial using information Jeeves had found.

Jeeves did most of the work, but it didn't go crazy, it didn't buy a suit. When I tell people about agents, one of the first things they raise is agents going rogue. While that risk is real, it mostly comes down to poor scoping. A properly scoped out task records what should be compared, what cannot be purchased or sent, how fresh the information needs to be, and what I will review.

Needless to say, this introduced a different problem: I am the bottleneck. Most of my tasks are partially automatable, and most of my tasks are sitting in the In Review stage.

A lot of things did break

This wasn't a walk in the park, though. It took me around eight hours of focused work to build all of this, including rebuilding my to-do list in the new system, followed by another four hours of debugging.

One of the biggest challenges felt slightly absurd. I had built a system specifically so work could progress without me sitting in front of my computer, but Codex's approval requests via Remote weren't appearing on my phone.

I went to Reddit and dozens of people said they had the same problem. This meant that after all that work, my supposedly autonomous personal operating system could still get stuck waiting for me to walk over to my Mac and click Approve.

We've literally built chopsticks that catch a rocket falling from space, so there had to be a fix. After some back-and-forth, I was able to build a small companion service that gave me a private approval inbox on my phone – literally an app with an interface where I can see the request and click Approve.

The dispatch loop that automatically picks up tasks to act on also took some time to get right. A task can be perfectly specified, an agent can be capable of doing it, and the work can still become stranded if the handoff isn't observable. At one point, every automated check was also opening a new Codex task, even when it was a tiny routine job I absolutely did not need to know about.

And there was the ElevenLabs API problem. I've four different audio workflows, and Codex has a quirk where I'd need to manually approve every new text-to-speech request – but that'd literally defeat the purpose of it being...an automation. That meant having to build a worker on my Mac that actually makes those requests, and also keeping my Telegram channel with the agent to receive the voice notes.

So much for one front door.

What actually changed

Despite all this, the system actually works.

Most things are only partially automatable, though, so they don't fully happen without me. Nonetheless, I do appreciate Jeeves fully dealing with canceling my Audible subscription without me having to navigate Amazon's million barriers to do it.

And now I can just say what I'm trying to achieve and let the system turn that into the next reviewable unit of work, rather than me being the routing layer for everything.

Jeeves can retrieve the minimum set of files relevant to the task rather than treating every note I've ever written as context. It can call a specialized worker without me remembering which agent owns which capability. Multiple tasks can progress to a useful first version without me doing all the work required just to get them started.

When my judgment is actually needed, the task comes back to me. Of course, I'd love to explore the boundaries of what can be automated. For instance, it'd be possible to have an agent fully deal with the customer support of a faulty product, something I did in part a few weeks ago, to a mostly positive result.

In any case, this is already very, very helpful. Most importantly, going back to the why of this essay, this means more time for the stuff I love doing.