Sulat.com / Writing on AIMonday, November 16, 2026
Agent Engineering/16 November 2026

Anthropic’s guide splits always-on agents into five parts, from inbox to outbox

Anthropic's new guide, written by William Hu, breaks an agent that runs across many sessions into an event inbox, timers, memory, permissions and an outbox. The post doesn't include sample code.

A glowing 3D orange starburst logo on a dark server-room desk between a glowing alarm clock and an inbox tray of envelopes

At a glance

  • Anthropic's guide splits an always-on agent into five parts: an event inbox, timers, memory, permissions and an outbox, all wrapped around the same core agent loop.
  • Anthropic says an always-on agent isn't actually always on: it sleeps, wakes for a run when an event arrives, saves what happened, then sleeps again.
  • Anthropic recommends a proxy outside the agent's environment that injects credentials into outgoing requests, so the agent never holds the real credentials itself.
  • For deferred tool calls, Anthropic says the run ends and the session is saved mid-call; the user's answer returns as an inbox event that starts a new run.
  • Anthropic says an agent should start quiet and earn more of the user's attention, and recommends building evals to tune how many messages it sends.

Anthropic has published Building always-on agents, a guide that breaks an agent running across many sessions into five parts: an event inbox, timers, memory, permissions and an outbox. William Hu wrote it for the Claude Platform, and it went up on 13 November 2026.

Anthropic describes always-on agents as stateful and proactive: they manage context across sessions and take actions without direct supervision. Underneath, they run on the same core loop as other agents. The difference is the architecture around that loop, which controls when the agent wakes up, what carries over between runs and how its work reaches the user.

Anthropic says the renewed interest comes from two things. The latest models have better judgment, it says, so they’re more reliable at understanding what a user wants and knowing when to check in. And intelligence is getting cheaper, with long-horizon tasks benefiting most. Its example: on one long-horizon coding benchmark, Opus 5.5 cost 78% less per solved task than Opus 5, compared with 40% less on typical workloads.

An agent that mostly sleeps

Anthropic says an always-on agent isn’t actually always on; that’s a description of the user experience. The agent spends most of its time asleep and wakes to do a run: it receives an event, completes its task and saves information about what happened. A run works inside a session, which is the transcript of messages and tool calls. Once the run finishes, the agent goes back to sleep and the cycle repeats.

Four-step loop: an event arrives, the agent wakes for one run, saves what happened, then goes back to sleep
The agent isn’t running all day; it wakes for a run, saves its state and sleeps again.

The five parts

Five labelled rows: inbox, timers, memory, permissions and outbox, each with a one-line job
Each of the five parts has one job in the loop.

Event inbox. Anthropic says letting each event source call the agent directly has failure modes: two events arriving together can start competing runs, and a crash can lose an event. Instead, every source sends its event to an inbox. The simplest version has a durable list of events, usually a database table; a handler, usually an HTTP endpoint, that writes to the list; and a worker, usually a background service, that reads from it. Anthropic recommends a relational database, one inbox per user to start, and deduplicating events by the source’s unique identifiers.

Its best practices for the inbox are to acknowledge events quickly, because some sources such as webhook providers treat slow responses as failures; to treat the inbox as the source of truth, so a new worker can retry an event if one dies mid-run; to keep one active worker per inbox; and to batch pending events, so several messages from a user in a row become one run and one reply.

Timers. Anthropic splits timers into follow-ups and schedules. A follow-up is a deadline the agent sets for itself, such as checking on a reply. A schedule is a recurring task on a known cadence, such as a daily newsletter. Timers live in their own durable store, separate from the inbox. A scheduler polls that store at a fixed interval, marks a follow-up done or moves a schedule to its next occurrence, then adds an event to the inbox and wakes the worker. Anthropic says you can build the scheduler yourself or use a durable execution engine.

Memory. Anthropic says memory gets its own store, implemented in its own products as a directory of files, and mapped to durable storage so memories outlive the worker. Its rule of thumb is to store only what the agent can’t look up again, and to save a pointer when the information already lives elsewhere, such as an issue tracker. It lists four kinds of memory:

Memory typeWhat it holdsHow it’s loaded
User instructionsWhat the user has said about how the agent should behaveIn its own file, at the start of every run
User notesThe user’s role, preferences and correctionsOne file at first; once split, only an index loads and the agent pulls files as needed
Past messagesWhat the agent has already told the user, so nothing repeatsIn a separate file loaded each run, or the worker loads the last few messages
Task progressWhat’s done and what’s left for each ongoing taskOnly an index loads at the start; the agent pulls task files as needed
Memory types as Anthropic describes them in its guide.

Anthropic also describes an optional step it calls dreaming, which reviews past sessions to curate memories, replacing outdated entries and finding patterns that only show up across many runs. Before any work, each run loads the system prompt, tool definitions and memory files. Anthropic recommends keeping that overhead lean and using prompt caching to lower costs. If a session gets too long, it says you can compact older messages or start a new session; both lose detail, so anything that needs to persist should go to memory along the way.

Permissions and deferred tool calls

Anthropic says permissions are where always-on agents carry the most risk, because a run holds the user’s access and operates unattended. For each tool call, the agent decides whether to proceed, block it or wait for approval. The guide names three components. The first is a credential store; Anthropic’s recommended pattern is a proxy outside the agent’s environment that adds credentials to outgoing requests, so the agent sends requests without credentials. The second is auto mode, which uses classifiers to review higher-risk actions and block dangerous ones; Anthropic says user review is still necessary for the most important decisions. The third is deferred tool calls.

When a call is deferred, the run ends and the session is saved mid-call. The request is shown to the user, for example through an interactive card built with MCP Apps, and the answer comes back as an event in the inbox. That event starts a new run, which resumes the saved session with the user’s input. While the call waits, Anthropic says the worker can pick up other events, so the agent isn’t blocked.

Four stacked steps: a call needs approval, the run ends and the session is saved, the user answers, a new run resumes
While a request waits for your answer, the worker isn’t tied up.

The outbox

Anthropic says always-on agents do most of their work in the background, so the user gets the outcome and a few details rather than a step-by-step stream. A run can end three ways: the agent sends a message to the outbox, decides nothing needs sending, or uses a deferred tool call to ask for permission or input. Most agents can get by with a “send” tool that delivers the message directly. A formal outbox, a separate table of outgoing messages read by a dispatcher, is only needed to pace messages or to recover from errors.

Anthropic recommends building evals to tune how many messages the agent sends, since too many makes it noisy and too few misses things the user needs. In practice, it says, it’s better for the agent to start quiet and earn more of the user’s attention over time.

Put together, every run starts with an event from the inbox. The worker wakes the agent in a new or existing session, the agent reads memory, works within its permissions and updates memory, then pushes a row to the outbox for the dispatcher to deliver. A run can set a timer that wakes the agent later, and a user’s reply comes back as another inbox event. The post doesn’t include sample code.


Discover more from Sulat AI & Tech News

Subscribe to get the latest posts sent to your email.