Chatbots have one thing in common: if you do not send a message, they do nothing. Engineering team Rubric Labs published “Designing an Always-On Agent” on November 5, 2026, to solve exactly that. Author Dexter Storey wants an AI that is always standing by, like Jarvis in Iron Man.
What is an always-on agent
Rubric Labs defines an always-on agent by three traits:
- Single-threaded: you talk to one AI, it remembers you, and you hand everything to it
- Proactive: it acts and messages you without being asked
- Situationally aware: it knows your schedule, email, and surroundings, so you do not have to explain the background each time
Compared with today’s chatbots and ordinary AI agents, Rubric Labs describes it like this:
| Always-on agent | Typical chatbot or agent | |
|---|---|---|
| Lifespan | One long-running thread | Short-lived, closed when done |
| How it starts | Wakes up on its own | Reactive, moves only when you speak |
| Source of information | Tracks its own environment | Sees only what you give it right now |
One thread without running out of memory
Putting everything into one conversation hits the limit of the context window (how much text an AI can read at once; past that, it cannot read more). To let it chat about your schedule, order dinner, and answer email in the same thread, you have to deal with that limit. Rubric Labs uses two moves.
Let the agent manage its own memory. The common industry approach is compaction: when a conversation gets too long, the earlier part is condensed into a summary. Rubric Labs found that compaction run by an outside process breaks the agent’s rhythm, like cutting off its train of thought and momentum.
So they did this instead:
- The agent sees how many tokens it has used on every turn
- A
foldContexttool replaces a range of messages with a summary the agent writes - A
dropContexttool deletes a range of messages outright
In practice, the agent usually waits for a lull, such as the end of a task, before compacting. It drops reasoning and tool logs it no longer needs and keeps what is still in use. To understand how AI memory works first, see AI Agent memory.
Send sub-agents to handle the time-consuming work. Ordering food or booking an appointment means operating a browser, and that takes a while. The main agent hands these jobs to sub-agents and keeps talking with you, and the main thread has more room left for the big picture. For how sub-agents work, see Skill, Sub-agent, Cron: three mechanisms.
Proactive: the heartbeat and a message tool
An ordinary agent is like a function: you send a request, it returns a result. To become proactive, it must be able to wake at any time and message you without waiting for you to write first. Rubric Labs adds two designs.
Heartbeat. At intervals, the system pushes a “heartbeat” message into the conversation, and the agent wakes up. It can fire on a fixed schedule, such as every hour, or the agent can schedule its own next wake-up.
Make “message the user” a tool. In normal chat, the last line of each turn is the reply you see. In this design, the agent must call the messaging tool before you receive anything. So it can wake up, finish its work, and decide there is nothing worth saying this time, without bothering you. Its last line stays in the thread as a note to itself.
Rubric Labs gives an example. The agent knows you are flying to Austin on Wednesday. During a routine heartbeat it spots the flight details, sends a sub-agent to gather directions from the airport to your lodging and check-in information, then schedules a heartbeat for around landing time so the message arrives as you touch down.
Situational awareness: broad access plus a notification inbox
For an agent to find things to do on its own, it has to know your situation. Rubric Labs provides two layers.
Broad access. If the agent can read your inbox, browser, and files, it can find the flights and lodging you booked and pick up your preferences. Rubric Labs notes that coding AIs got strong from a single tool for running terminal commands, and general-purpose agents can do something similar with computer-use tools.
A notification system. Access alone is not enough, because the agent does not know what it does not know. So Rubric Labs gives it an inbox, and events on the internet are pushed in as they happen. When a flight is canceled, the agent can find a replacement right away and notify you, instead of discovering it an hour later.
A problem follows. The inbox soon fills with promotional email, Slack messages meant for someone else, and irrelevant project notifications. If every one wakes the agent, it might wake every minute and burn tokens (the unit AI usage is billed in) for nothing. One approach Rubric Labs suggests is to have a smaller model judge whether each item is important. Important ones wake the agent, and the rest pile up for the agent to read in bulk when it has time.
The hardest part: judgment
Storey argues that the architecture above is a fairly simple combination, and the real problem is the model itself:
“Today’s models are very very bad at this, because they lack discernment.”
His explanation is that models are trained to finish tasks, so they do well when the signal is clear and run into trouble in ambiguous environments. His example is Slack: the agent acts on a message that was not meant for it, finds it lacks the permissions and background, and ends up producing a design doc. His verdict is that this is useless and embarrassing. The reverse also happens, and the agent misses moments when it should act. How to balance too eager against too passive, he says, is learned by experience and cannot be tuned with a formula.
His recommendation is to have the agent start out shy, build confidence over time, and find the range where it is useful. Concretely, three things:
- The system prompt states what it is responsible for and says plainly that doing nothing is fine
- When unsure whether a task is its own, it asks instead of guessing
- It remembers how you reacted to each action (thanks, a correction, or silence) and checks that memory before the next one
Three reminders for beginners
- This is a design approach. The post offers no measured results and does not say how well it works. Treat it as a map for understanding persistent AI.
- The broader the access, the more the agent can do, and the greater the risk of mistakes or manipulation. See AI Agent security risks.
- To understand how an agent and a language model divide the work, start with An AI Agent Is Not AI.