Pick up almost any productivity book and the advice rhymes: do tasks faster, batch them, time-block them, two-minute-rule them. It’s all about getting you through the list more efficiently. For decades that was the only lever, because you were the only one who could do the work.
That assumption just broke. For a growing slice of my to-do list, I’m no longer the only one who can do it — an AI agent can. And once that’s true, the most valuable thing a to-do app can do isn’t reminding me faster. It’s helping me not do some tasks at all.
The delegation most apps can’t do
We already delegate to people: you assign a task to a teammate, they do it, you check the result. Every project tool supports this. What none of them supported until recently was assigning a task to software that does the work — not a reminder, not an automation rule, but an agent that reads the task, performs it, and reports back.
Coding agents like Claude Code and OpenAI Codex are now good enough to do well-scoped jobs end to end: a refactor, a first draft, a research round-up, a batch of tests. The bottleneck isn’t their ability. It’s that most of our task lists have no way to hand them work — so we copy-paste into a chat window and lose the thread.
What changes when the list can delegate
When your to-do app can hand a task to an agent, the act of writing a task down changes meaning. Some items are still for you. But others — the scoped, boring, well-defined ones — become things you simply assign and forget, the same way you’d hand them to a junior colleague.
I notice it most in the gap between “I should do X” and “X is done.” That gap used to be measured in days of avoidance. Now, for the delegatable tasks, it’s measured in how long the agent takes plus the minute I spend reviewing. The list shrinks while I’m doing something else.
The non-negotiable: keep the checkbox
Delegation only works if you stay in control of what counts as done. This is the part people get nervous about, and rightly — an agent that marks its own homework complete is a recipe for quiet disasters.
So the rule that makes this safe is simple: agents propose, you dispose. In Lume, an agent can only ever move a task to “ready for review,” never to done. Completion stays a human action. The worst case isn’t a wrong thing shipped — it’s a wrong thing sitting in your review queue that you reject in two seconds. And because every change is undoable, even a bad call costs you one keystroke.
Not everything should be delegated
To be clear, this isn’t “let the robot run your life.” Judgment calls, relationships, anything irreversible — those stay yours. The skill that matters now is triage: looking at a task and knowing whether it’s a you-task or an agent-task. Get that sorting right and your own attention flows to the things that actually need a human.
Most of us are still doing it the old way — grinding through a list that’s full of work a machine would happily take. The apps that win the next few years won’t be the ones with the prettiest reminders. They’ll be the ones that let you delegate.
That’s the whole bet behind assigning tasks to Claude Code and Codex in Lume — a list that doesn’t just remind you, but does the parts you shouldn’t have to.