Autonomous Claude Tasks

I have a to-do list. Claude checks it every hour. When something’s due, Claude does it while I’m asleep.

This isn’t a hypothetical—it’s been running for weeks. Here’s how it works.

The Setup

I use Todoist for task management. Any task tagged with @c (for Claude) becomes eligible for autonomous execution. When the due date hits, a daemon picks it up, spawns a Claude session, and executes the task.

The output lands in a designated folder. I review it in the morning.

Todoist (@c label) → poll.ts → Claude agent → output folder

No human in the loop during execution. That’s the point.

What Claude Does Autonomously

Research is the sweet spot. Things like:

“Research the latest on [topic] and summarize key points”
“Find competitor examples for [feature]”
“Review this month’s changelog and draft a summary”
“Analyze the pattern in these error logs”

Anything that requires gathering, synthesizing, and writing—Claude handles it well.

What I don’t delegate: anything that touches production systems, sends messages to people, or makes irreversible changes. The guardrails are explicit.

The Permission Model

The tricky part of autonomous AI is trust. How do you give Claude enough rope to be useful without giving it enough to hang you?

The answer is whitelisting, not blacklisting.

The autonomous agent runs with a restricted tool set:

Allowed: Read, Write (to a specific folder), Glob, Grep, WebFetch, web search
Blocked: Edit (can’t modify existing files), Bash (can’t run commands)

A hook validates every write operation. If Claude tries to write outside the designated output folder, the operation fails. This isn’t a suggestion—it’s enforced at the system level.

The agent also runs in “don’t ask” mode. If it encounters something it doesn’t have permission for, it fails rather than prompting. There’s no human to prompt at 3am.

Why This Matters

Delegation is the founder bottleneck.

I know what I should delegate. I know roughly who should do it. But the friction of writing up the task, providing context, checking in on progress—that friction means things stay on my list longer than they should.

Claude removes that friction for a category of work. Research tasks that would sit in my queue for days now complete overnight. The output isn’t always perfect, but it’s usually 80% there—enough to review and refine quickly.

The psychological effect matters too. Seeing tasks complete while I sleep changes how I think about my to-do list. It’s not just a record of what I need to do—it’s a queue of work that’s actively being processed.

The Actual Implementation

The daemon runs hourly on a remote server. It:

Polls Todoist for tasks tagged @c that are due
Extracts the task description
Builds a prompt with context from my vault
Spawns a Claude session with the autonomous agent
Writes output to a review folder
Marks the task complete in Todoist

The agent itself is defined in a markdown file that specifies permissions, available tools, and system context. Claude Code’s agent system handles the rest.

Total code: maybe 200 lines of TypeScript. Most of the work was figuring out the permission model.

What I’ve Learned

Specificity matters. “Research competitors” fails. “Find three SaaS companies doing [specific thing] and document their pricing models” succeeds. The more specific the task, the better the output.

Overnight is the killer use case. The value isn’t just saved time—it’s that work happens during dead hours. By morning, I have a head start.

Review is non-negotiable. I don’t auto-publish anything Claude produces. Everything goes through a review folder. This is psychologically important: I’m still the decision-maker, just with better inputs.

The guardrails pay off. I haven’t had a single “oh shit” moment because the permission model is restrictive by default. Better to have Claude fail on something it should have been able to do than succeed on something it shouldn’t.

The Broader Pattern

This is what’s possible when AI tooling is programmable.

Claude Code isn’t just an assistant I chat with—it’s infrastructure I can build on. Agents, hooks, scheduled tasks. The same interface I use interactively becomes something I can automate.

We’re early in this. Most AI usage is still interactive, one-off, chat-based. The interesting stuff happens when AI becomes part of your systems, running continuously, handling work you’d otherwise ignore.

I gave my AI a to-do list. It’s been doing its homework ever since.