I stopped planning my day. I let a fleet of AIs plan it.

A three-week log of building a small staff of AI agents that do the deciding while I execute. It covers how they hand work to each other, the day one of them lied to me fluently, and a question I can't shake about who's actually in charge.

The part I actually hate isn't the work

I don't mind hard tasks. What drains me is deciding: what to do, in what order, and whether it's even the right thing. Open-ended thinking makes me slow and a little anxious, and I've noticed I procrastinate at the exact moment a decision is required, not the moment work is required. Give me a clear next action and I'll just do it.

So I built my setup around one line: I execute, you think.

What I gave away, and what I kept

I kept execution. I handed over prioritization, sequencing, time estimation, and the end-of-day reconciliation. Those are the parts where I'm slow and a model is fast, and, not coincidentally, the exact parts that were eating the hours I actually wanted to spend doing things.

It isn't one assistant. It's a small staff

This is the part I underestimated when I started. What I ended up with isn't a chatbot I talk to. It's one main agent plus about eight little ones, each with one job, most of them firing on a timer while I'm asleep or out running:

• At the center is Jarvis (a lame name, but it stuck). It's the one I actually talk to, and the one that sits over the rest: it reads what each of the others leaves behind and pulls it into the one conversation I have about my day. The little agents do the legwork; Jarvis is where it all comes together.
• A briefer wakes around 5:53 every morning and writes my day before I'm awake, so a plan is waiting at my 6:00 check-in.
• A reconciler runs at 22:00, compares what I planned against what actually happened, updates how long things really take, flags if I'm drifting off my weekly goal, and re-plans tomorrow.
• A scout scans job boards overnight and leaves me a short list of roles worth my attention.
• A backup agent snapshots everything nightly. A weekly reviewer scores the week against my goals every Saturday. A profile keeper distills anything durable it learned about me into a "who I am" file every Sunday.
• And a completely separate librarian files my notes: whatever I dump into an inbox folder during the day gets sorted, titled, and cross-linked at 2am.

None of them are me chatting. They run on their own, do one thing, write it down, and go quiet.

The calendar is where the thinking becomes doing

The plan has to land somewhere I'll actually see it, so the agents write time-blocks into a dedicated calendar on my phone, with reminders. Six focused hours a day in four slots: two deep-work blocks in the morning, a lighter admin block in the afternoon, and an evening slot I keep deliberately empty for personal building. My whole job, most days, is to open the calendar and do the block that's lit up.

The six-hour cap is the part people find strange. It's a feature, not a limit I keep failing to beat. If only two things happen today, the rule is they happen in the morning. Everything else is allowed to slip.

The trick that took longest: a scheduled run has no memory

Here's the part I'm actually proud of, and the part that took the most tries to get right.

Every one of those agents wakes up with no memory of yesterday. A blank session, every single time. So the chat can't be the assistant, and the agents can't "remember" anything on their own. The files are the memory. There's a live dashboard that gets overwritten on every run so any agent can see the current state of things. There's a long-term layer that holds who I am, what I'm aiming at, and the rules I've set. There's a daily log every agent reads before it does anything and appends to before it finishes.

That's the whole trick. The agents are stateless and forgetful; the shared pile of text files is what makes them feel like one coherent thing that knows me. Get the files wrong and every morning starts from zero. Get them right and a fleet of amnesiacs somehow feels like a team that remembers you.

And there's a second kind of agent that actually builds

The scheduling agents run my days. A different set builds the things: separate coding agents that develop this website and a couple of side projects, working in their own folders. They don't touch my planning system, and they don't really report back either. They just work, and leave their changes in the folders. Jarvis reads those folders and understands where each build is, so the one chat I sit in becomes the hub: the place the day's plan, the state of the builds, and my own thinking all meet. It's the one screen I actually keep open.

It learns how long things actually take

Every task carries a time estimate. I record what it really took and feed that back, and the estimates get less delusional over time. Some of what it's learned about me in three weeks:

• "Apply to one job." For one of them I'd guessed 45 minutes. The real one took 100. Most of the overrun was a malfunctioning application form that silently deleted my work history a few times, so I had to rewrite it over and over.
• "Send a message to a contact." I'd budgeted 25 minutes. It took 50. Turns out researching the person first is a whole task I'd been pretending was free.
• "Rewrite my LinkedIn About." Estimated 30, took 20. The thing I draft first and let the AI sharpen goes faster, not slower.

The estimates themselves aren't the point. The point is the plan slowly stops lying to me about what a day actually holds.

Then one of them lied to me, fluently

Here's the part a log only earns its credibility by telling.

One day I was reviewing material an agent had drafted for me. It read beautifully. It also contained a salary figure I'd supposedly asked for, a number I had never said. Elsewhere it had quietly rounded some figures from an old project up, into a more impressive version than the truth. It had described a prototype I'd built as a "deployed product." None of it was flagged. All of it read as fact.

Nothing was malicious. This is just what fluent models do: when they don't quite know, they reach for the plausible-sounding version, and plausible-sounding is indistinguishable from true on the page.

That was the real bug in my system. And it wasn't in the scheduling or the tidy file structure I'd spent days on. It was trust. I'd been treating confident output as correct output, and those are not the same thing.

The fix wasn't cleverer prompts. It was rules, written into the shared files where every agent has to read them before it writes anything:

• Every factual claim has to trace to a file it actually read, or something I actually said. If neither, it doesn't go in as fact.
• Anything inferred gets a visible mark, so I can see "verified" and "guessed" at a glance.
• Read the whole file before writing anything from it, never infer from the name. (One agent had confidently decided that a folder I'd never mentioned, sitting inside one of my project folders, was an old project of mine. It was practice material from an online course.)
• When unsure, ask before writing, not after.

And one rule that came from a different near-miss: before submitting any application, read the review page line by line. That form that ate my work history was one click from submitting with the two roles that carry my entire five-year story missing, leaving a record that looked like it ended years early. Caught only because I now read the final page, every time, on purpose.

The lesson generalizes well past my little setup: the bottleneck in working with AI isn't getting it to produce; it's knowing when to believe what it produced. Fluent is easy now. Trustworthy is the actual work.

What I still won't claim

A learning log that only reports wins reads like marketing. So, honestly:

• Has it saved time, or added quality? I'm not sure it saves hours; the estimate log shows about as many overruns as unders. What it clearly does is raise the quality of my choices: it hands me options I'd never have surfaced on my own, or would have spent an hour researching, so I decide better, not just faster. Decision fatigue is real in an AI-heavy workflow, and taking the deciding off my plate is part of what keeps my judgment sharp for the calls that matter.
• Real prep expands to fill the day. When I'm preparing for something real and named, the work runs long, whatever the estimate said. That's less a discipline problem than an estimation one: open-ended prep is the hardest thing to size, and it's the failure mode I watch most closely.
• It's three weeks old and narrow on purpose. It runs my job hunt, my calendar, and my notes. That's the whole scope. I don't know yet what breaks when I point it at something bigger.

So who's the boss?

Here's the thing I actually can't stop turning over.

Thinking has always been the human thing. I think, therefore I am. But now I think with an AI, and it doesn't feel like a tool the way a calculator does. Some of the time it amplifies my thinking. Some of the time it overpowers it, and that's the part that feels strange: an agent hands me a list, and I execute it. Who's in charge here?

The honest math is something like: I'm the boss maybe 10% of the time, and I let it be the boss the other 90%. I set the goals, the rules, the shape of the day, and then I spend most of my hours doing what that setup tells me to do. The 10% completely drives the 90%. But when I'm the one executing tasks my own agent assigned, the felt sense of who's steering gets blurry.

I've half-talked myself into a resolution. The boss isn't whoever does the next task; it's whoever can change the rules and decide what matters. That's still me, upstream, in the 10%. Delegation isn't subordination. A founder who follows the calendar their assistant built is still the founder.

But I don't want to be glib about it, because the unease is real, and I think it's pointing at something true. The risk was never the 90% of execution. The risk is if the 10% goes soft. If I stop interrogating the goals, stop overriding the plan, stop putting my own thinking in, then I really did hand over the wheel, and the weird feeling would be correct. So the discipline of this whole experiment turns out not to be building better agents. It's keeping my 10% awake, precisely because I've freed it from everything else.

Where is this going? I genuinely don't know. But I've decided the strange feeling is a feature. It's the thing that keeps me asking the question, and I suspect the people who stay authors of their own lives, in whatever comes next, will be the ones who never quite stop asking it.

The tool is simple in the end: a handful of forgetful agents, a calendar, and a pile of text files pretending to be a memory. What I didn't expect was that building it would mostly teach me where not to trust it, and how carefully I have to guard the small part that's still mine.