Always-On Agents

Most AI assistants are glorified chatbots. You send a message, they send one back. You ask a question, they answer. The conversation window is the entire relationship. It's a fundamentally reactive model — the agent exists only when you're actively poking it.

I've been living with something different for the past few months, and it's changed how I think about what an AI assistant can be. Not a chatbot you summon when you need something, but an agent that's actually running, continuously, in the background. One that has a heartbeat.

The Heartbeat

Here's the core idea: instead of an agent that wakes up only when you message it, imagine one that wakes up every 15 minutes on its own. It checks a queue. It looks for work. It processes todos that have been pushed into its system — by you, by other agents, by scheduled tasks, by external systems. Then it goes back to sleep. Fifteen minutes later, it wakes up again.

This sounds simple, almost boring. But it completely changes the relationship.

With a traditional chatbot, every interaction is synchronous. You're both there, in the conversation window, trading messages back and forth. The agent has no concept of time passing outside of that exchange. It can't do anything while you're away. It can't remember to check on something later. It can't work on a task that takes three hours when you only have five minutes.

With an always-on agent, time becomes a resource the agent can actually use. You can hand it a task in the morning and check back in the afternoon. You can tell it "remind me about this in three hours" and it actually will, because it'll create a todo for itself scheduled for three hours from now. When the heartbeat runs and sees that todo is ready, it processes it.

The Todo Queue

The architecture is straightforward: there's a queue of todos. Each todo has a status (new, pending, completed, blocked), a priority (high, medium, low), and optionally a scheduled time. External systems can push todos into the queue. The agent pulls from the queue when it wakes up.

This might sound like a boring implementation detail, but it's the foundation of everything else. Because once you have a queue that anything can write to, you've decoupled "asking the agent to do something" from "having a conversation with the agent."

A cron job can create a todo. A webhook can create a todo. Another agent can create a todo. The agent itself can create a todo for its future self. I can create a todo from my phone using a shortcut, even if I'm not in front of my computer. The agent doesn't care where the work comes from. It just processes the queue.

This is fundamentally different from a chatbot where the only interface is "send a message in a conversation."

Self-Scheduling

The killer feature, the thing that makes this feel like magic: the agent can schedule work for itself in the future.

Let's say I ask the agent to monitor a deployment. In a traditional chatbot model, I'd have to remember to come back and ask "hey, how's that deployment going?" An always-on agent can add a todo to its own queue: "Check deployment status in 30 minutes." When the heartbeat runs 30 minutes later, it sees that todo, checks the deployment, and can notify me if something's wrong.

Or I tell it to research something and write a summary, but I know it'll take a while and I don't want to sit there waiting. The agent can break it into steps: research now, schedule a todo to synthesize findings in an hour, schedule another todo to send me the summary when I'm back online.

It's time-shifting for AI work. The agent becomes something that can operate across hours or days, not just across a single conversation.

What This Unlocks

The first time you actually use this, it feels weird. I'm used to AI assistants being tools I invoke. I open the app, I ask a question, I get an answer, I close the app. The assistant exists only in that moment.

With an always-on agent, I'll get a notification in the middle of the afternoon: "Hey, that thing you asked me to check on this morning? It's done." I didn't have to remember to follow up. I didn't have to come back and ask. The agent just did it and told me when it was ready.

Or I'll wake up and see that overnight, the agent processed a backlog of todos I'd queued up the night before. It ran through them while I was asleep, left notes on what it found, flagged a few things for me to review.

This is profoundly different from a chatbot. It's closer to having a colleague who works weird hours but is always reachable. I can hand them something and trust it'll get done. I can ask them to remind me about something later and they will. I can give them a multi-step task that'll take all day and they'll just work through it.

The Mental Model Shift

The shift isn't just about features. It's about how you think about the agent.

With a chatbot, the mental model is transactional. I need something, I ask for it, I get it, we're done. The assistant is a tool I pick up and put down.

With an always-on agent, the mental model is collaborative. There's a sense of persistent presence. The agent isn't just responding to me in the moment — it's tracking things over time, managing a workload, making decisions about what to prioritize.

I've caught myself doing things I never did with previous AI assistants. I'll add a todo for the agent at 11pm, knowing it'll process it on its next heartbeat. I'll ask it to check on something "in a few hours" without thinking twice. I'll hand it a vague research task in the morning and trust that by afternoon there'll be something useful waiting for me.

It feels less like using software and more like delegating. There's trust involved. Not in the sense that the agent is infallible, but in the sense that I can hand it something and stop thinking about it, confident it'll either get done or flag itself as blocked.

Living With It

The day-to-day reality is that I don't think about the heartbeat or the todo queue or any of the architecture. I just know that if I need the agent to do something later, I can ask, and it'll happen. If I want to be reminded about something, I can say so, and I will be. If I kick off a long-running task, I can go do other things.

There are still rough edges. Sometimes I want something done immediately and have to remember to mark it high priority. Sometimes the agent picks up a todo and gets confused about context it's missing. Sometimes I forget what I've queued up and get a notification that surprises me.

But the core experience is solid enough that I can't imagine going back to a purely reactive assistant. It's like the difference between email and instant messaging. Both have their place, but they're different tools for different workflows. And once you have async communication with an AI assistant, the synchronous-only version feels limiting.

What's Next

This is still early. The architecture works, but there's a lot to figure out about how humans and always-on agents should interact. How do you design notifications so they're useful but not annoying? How do you give visibility into what the agent is working on without overwhelming someone with status updates? How do you handle failures gracefully when a todo gets stuck?

I don't have great answers yet. But I know this model is pointing at something real. The shift from reactive to proactive, from synchronous to asynchronous, from tool to colleague — it changes what's possible.

And honestly, it's just more useful. I can get more done. I can hand off more cognitive overhead. I can trust that things will happen without me micromanaging every step.

That's what I wanted from an AI assistant all along. Not a smarter chatbot. A system that actually takes things off my plate and runs with them. Something that works even when I'm not watching.

Turns out the trick was just letting the agent run.