Always-On Agents Need Five Patterns to Stay Useful

always-on agents

Most AI agents work the way a contractor works. You give them a task, they complete it, and the engagement ends. When you come back the next day, they remember nothing. That is fine for a single question, but it is a poor fit for work that continues across days, survives interruptions, or needs to react to events while nobody is watching. Always-on agents are an attempt to close that gap. Instead of starting fresh each time, they keep a durable record of what happened, wake up on a schedule or in response to a trigger, and hand off their work through controlled boundaries.

The idea sounds simple until you try to build it. A long running agent needs memory that survives a reset, a way to be woken, a system for permissions that does not require a human to approve every step, and a method for sending results out without duplicating them. Always-on agents therefore depend less on any single model and more on the architecture around the model. This article examines the five patterns that make persistent agents practical, maps each one to documented mechanisms that exist today, and separates what is well supported from what is still a design idea. It also looks at the cost and safety questions that decide whether an always-on deployment is worth running.

Why always-on agents need more than a conversation

A normal agent session has a beginning and an end. The model receives a prompt, calls tools, and returns an answer. Everything it learned during that exchange lives in the context window, which disappears when the session closes. This works for short tasks and fails for anything that spans time. A bug fix that waits on a review, a report that updates every morning, or a monitoring job that reacts to an alert all need state that outlives one conversation.

This is the problem that always-on agents are built to solve. Rather than treating each run as an isolated event, the design treats the work as a continuous process made of many short sessions. Each session picks up where the last one stopped, and the record connecting them is stored outside the model. Anthropic's engineering team described this plainly in its work on long running agents: they must work in discrete sessions, and each new session begins with no memory of what came before. The work of always-on agents therefore breaks into five patterns.

The shift has a practical consequence. When you design always-on agents, you stop asking how to keep one conversation alive forever and start asking how to make a series of small conversations behave like one continuous worker. That change in framing drives every pattern that follows. It also explains why context window size is not the answer. A larger window helps inside a session but does nothing for the gap between sessions. Always-on agents are, in other words, an architecture problem before they are a model problem.

For teams already running cloud based agent compute, this is a familiar boundary. Our look at the cloud computer for AI agents covers the infrastructure side, while this article focuses on the software patterns that sit on top of it. Always-on agents need both layers to work.

Pattern one: a durable event inbox

The first pattern is a durable record of everything that has happened. Anthropic's Managed Agents research defines a session as the append only log of everything that happened in a run. The harness writes to that log with an emit event call, the brain reads it with a get events call, and a session can be resumed later with a wake call that reloads the log and continues from the last recorded event. This is the closest documented equivalent to what many architects call an event inbox.

The value of an append only log is that it removes ambiguity. Always-on agents do not have to guess what they did yesterday or whether a step completed. The log is the record. If a run crashes halfway through, a new session can read the log, see the last completed action, and continue. If two workers need to coordinate, the log gives them a shared source of truth rather than a set of conflicting local notes. For always-on agents, that shared record is what makes a series of short runs behave like a single worker.

It is important to be precise about vocabulary. The phrase event inbox is a useful architectural label, but it is not the name of an Anthropic feature. The documented mechanism is the session event log in Managed Agents. Treating the label as a product name would mislead anyone trying to implement it. The pattern is real, the documentation is real, and the two are connected by the mechanism rather than by a shared brand.

The same research describes a worker process that claims sessions from a queue and runs their tool calls. That is the other half of the pattern. A log stores the state, and a single worker consumes it in order. Keeping one worker per session avoids the race conditions that appear when several processes try to advance the same task at once. Always-on agents that skip this discipline tend to duplicate work or overwrite each other's state.

Pattern two: timers and scheduled wake ups

An agent that only wakes when a human sends a message is not truly persistent. It still depends on someone remembering to prompt it. The second pattern gives the agent its own sense of time. Anthropic's scheduled tasks documentation, currently marked as a research preview, describes tasks that run in the cloud on a recurring cadence, at a specific future time, in response to API calls, or on GitHub events. Each run is a full Claude Code cloud session, created fresh for that execution.

That last detail matters. A scheduled run does not keep an old conversation open. It starts a new session, which is exactly why the durable log from pattern one is needed. The timer decides when to wake, and the log tells the new session what it needs to know. Always-on agents combine the two, and neither is useful on its own. A timer without memory produces a series of forgetful runs, while memory without a timer waits for someone to call it.

Cron expressions and calendar style schedules are both supported in the documented system, and a task can post a summary to a channel so that the team starts the day with an updated queue. That example shows the intended role of timers in always-on agents. They are not just reminders. They are the mechanism that turns a reactive tool into a proactive one, capable of producing work before anyone asks for it.

Because scheduled tasks are labelled a research preview, the exact API surface may change. Anyone building on the pattern should expect the interface to move while the underlying idea stays stable. We discussed similar execution boundaries in our coverage of sailboxes for persistent agent compute, where isolation plays the role that scheduling plays here.

Pattern three: memory that survives and gets curated

Memory is the most discussed pattern and the easiest to get wrong. For always-on agents, memory is what turns a collection of unrelated runs into a worker with continuity. Anthropic's memory tool documentation describes a memory file directory where an agent can create, read, update, and delete files that persist between conversations. The documented use case is maintaining project context across multiple agent executions, and one system instruction is deliberately blunt: assume interruption, because the context window might reset at any moment. That instruction captures the mindset required for always-on agents. You write things down because you cannot count on staying awake. Any system that hopes to keep long running agents coherent has to treat the memory layer as essential infrastructure rather than an optional feature.

Claude Code adds another layer with user memory and automatic memory, stored in locations such as a user level instruction file. The point is not just storage but placement. Information about the person, the project, and the current task belongs in different layers, so that the right context is loaded at the right time. Dumping everything into one file makes retrieval slow and increases the chance that stale notes influence current decisions.

The most interesting addition is curation. Anthropic's engineering post on the components of agent memory describes a process often called dreaming, in which the agent tests its notes against the original transcripts, catches its own errors, and rewrites them. The same post notes that the injected memory layer is kept small, with practical limits on how much is loaded at once. Always-on agents accumulate notes quickly, so a mechanism for checking and compressing those notes is not a luxury. Without it, memory becomes a growing pile of unverified claims.

This is where the pattern connects to cost and reliability. A compact, curated memory means shorter prompts and fewer mistakes. A sprawling memory means the agent spends more tokens reading its own history and may act on something it misremembered. The quality of memory in always-on agents is therefore a direct driver of both accuracy and spend.

Pattern four: permissions and safe handoffs

The fourth pattern is the one that decides whether always-on agents can be trusted to act without supervision. An agent that runs on a schedule and remembers its history is also a system that can take actions while nobody is looking. Permissions have to be designed for that reality. The longer a system runs, the more chances it has to encounter a situation its designers did not anticipate.

Anthropic's research on Claude Code auto mode describes delegating approvals to model based classifiers. A transcript classifier running on a separate model evaluates each action before it executes, and a faster filter handles obvious cases first. The published figures are specific: the transcript classifier had a 17 percent false negative rate on real over eager actions, while the containment work reports that auto mode catches roughly 83 percent of over eager behaviors. Those numbers are a reminder that classification reduces risk without eliminating it. Always-on agents still need a path for the cases the classifier misses.

Hooks provide a more deterministic layer. The documented hooks fire at points such as before and after tool use, and the pre tool hook can return allow, deny, or ask decisions. That gives a developer a place to enforce hard rules that do not depend on a classifier's judgment. Auto mode adds a related behavior called deny and continue, where a blocked action comes back as a tool result so the agent can find a safer path instead of stopping. Escalation follows repeated denials, which keeps a stubborn agent from looping forever.

Credential handling is the other half of the safety story. In the Managed Agents design, tool calls go through a dedicated proxy that fetches credentials from a vault, and the harness is never made aware of any credentials. The containment post puts it more simply: credentials never enter the sandbox. For always-on agents this is essential. A long running process that holds secrets in its own context is a much larger risk than one that never sees them. Our broader look at securing persistent agents goes deeper on that threat model.

Pattern five: an outbox for results

The final pattern is about getting work out of the agent safely. An agent can produce a message, a commit, or a summary, but delivery is a separate concern. If the agent sends a result directly and the process crashes halfway, the result may be lost or duplicated. The standard fix is an outbox: a durable table of outgoing events that a separate dispatcher reads and delivers. Amazon Web Services documents this as the transactional outbox pattern, where an outbox table stores all the events and a separate service reads from it and sends them onward.

No Anthropic page uses the word outbox as a named feature, so this pattern should be presented as a general distributed systems technique rather than an Anthropic product. What Anthropic does document is the dispatcher side. Scheduled tasks can post a summary to a channel, connectors can send results into other tools, and hooks can react to events at defined points. Always-on agents put those pieces together with a durable outbox so that a result is recorded once and delivered reliably.

The outbox also solves a subtle problem with retries. If an agent wakes, produces a result, and fails before marking the task complete, the next session might produce the same result again. With an outbox, the result already exists in the table and the dispatcher can finish the delivery without asking the model to redo the work. That is a small piece of plumbing that prevents a very visible class of bug in always-on agents.

This pattern is borrowed from systems that have been solving exactly this problem for years. Always-on agents are, in this respect, not a new category. They are a new consumer of old reliability patterns, applied to a component that is less predictable than a traditional service.

What the cost numbers actually say

Cost is the question that follows every architecture discussion. It matters more for always-on agents than for one off tasks, because a persistent worker spends tokens every day it runs. Anthropic's Claude Opus 5.5 launch page states that the model costs 40 percent less than Opus 5 on typical workloads, with prices of 4 dollars and 20 dollars per million input and output tokens, and cache reads at 20 cents per million. The same page lists specific coding comparisons, including 51 percent less on a HAProxy C to Rust task and 50 percent less on a merger task. These are official figures and can be used directly.

A larger percentage has circulated in secondary summaries, claiming a 78 percent reduction per solved task on a long horizon coding benchmark. That figure could not be verified against any official source. It does not appear on the launch page, in the documentation, or in the engineering posts, and searches returned only social posts echoing the same secondary summary. The responsible move is to omit it. The official page itself cautions that benchmark margins have become a less reliable guide to real world differences, so even the verified percentages should be read as context rather than a promise.

For always-on agents, the more useful cost lesson is structural. A persistent architecture spends tokens on memory reads, classifier checks, and repeated small sessions. Cheaper tokens help, but a well curated memory and a disciplined event log often save more than a price cut. The 40 percent figure is welcome, and it does not remove the need to design carefully. Teams comparing gateway costs may also find our AI gateway comparison useful context.

Where the patterns are still a design idea

It would be misleading to present all five patterns as finished products. The session log, scheduled tasks, memory tool, hooks, and classifiers are documented mechanisms that exist today. The neat five part model that groups them into an inbox, timers, memory, permissions, and an outbox is an architectural way of thinking, not an official framework with that name. Some of the labels come from the analysis rather than from a vendor's documentation.

That distinction matters when you go looking for documentation. Searching for an event inbox feature or a deferred tool call setting will not find a page, because those exact names are not used. Searching for the session event log, scheduled tasks, the memory tool, hooks, or the transactional outbox pattern will. Always-on agents are built from parts that have real names and real documentation, and the composite idea is the layer that developers add themselves.

There is also a maturity gap. Scheduled tasks are a research preview, classifier based permissions have measurable error rates, and dreaming style memory curation is described in an engineering post rather than shipped as a standard feature. None of that makes the architecture unusable. It means that always-on agents are a set of tradeoffs to manage, not a switch to flip. The teams that treat them as systems, with logs, schedules, memory hygiene, hard permission rules, and reliable delivery, will get the most value from them. Always-on agents built this way are less flashy in a demo, but they are the ones that still work a month later.

Questions readers are asking

What are always-on agents? They are AI agents designed to keep working across sessions. Instead of starting fresh with each prompt, they keep a durable record of past events, wake on schedules or triggers, and act through defined permission boundaries.

Do always-on agents need a bigger context window? No. A bigger window helps within one session but does nothing between sessions. The durable event log and memory layer are what let a new session continue the work of an old one, regardless of window size.

Is there an official event inbox feature? No. The term describes a pattern. The documented mechanism is the append only session event log in Anthropic's Managed Agents research, which a new session can reload and continue.

How does memory stay accurate over time? Through layered storage and curation. Notes are kept in files that persist between sessions, and an engineering approach called dreaming tests those notes against original transcripts and rewrites errors. Keeping the injected layer small also helps.

Can always-on agents be trusted to act without approval? With limits. Auto mode uses classifiers that catch roughly 83 percent of over eager behaviors, and hooks can enforce hard allow, deny, or ask rules. Credentials are kept behind a proxy so the agent never sees them directly.

Was the 78 percent cost reduction officially confirmed? No. Only the 40 percent figure on typical workloads is verified on the official launch page. The 78 percent claim could not be found in official sources and should not be attributed to them.

Sources

[fluentform id="2"]