RSS
Tips

Anthropic's always-on agent guide: the five parts, and a minimal build plan

Anthropic's November 13 guide says an always-on agent is mostly asleep: short runs started by inbox events, including timer events, with memory, permissions and an outbox around the same agent loop. Here are the five parts and one way to build them.

black desk lamp on brown wooden table
Photo by Beth Stevenson on Unsplash

Anthropic published "Building always-on agents" on November 13, 2026, a best-practices guide by William Hu on the Claude resources site. Its core point: an always-on agent is not actually always on. It spends most of its time asleep and wakes for short runs, each started by an event. What makes it feel continuous is the architecture around the normal agent loop.

The guide names five primitives: an event inbox, timers, memory, permissions and an outbox. Rather than announcing a new API, it describes them as durable tables, background services and files, built on Claude Code and API features Anthropic already ships. It gives no code; the build sketch further down is ours.

Runs and sessions

A run is one stretch of work: the agent receives an event, completes its task and saves what happened. A run happens inside a session, the transcript of messages and tool calls. Events that continue earlier work, such as a user reply, resume an existing session; anything else starts a new one.

1. Event inbox

Instead of letting every webhook or job call the agent directly, every source writes an event to an inbox and a worker picks it up. Calling the agent directly can start competing runs when two events arrive together, and a crash can lose an event. The simplest version has three parts: a durable list of events (usually a database table), a handler that writes to it (usually an HTTP endpoint), and a worker that reads from it (usually a background service).

  • Acknowledge events quickly; webhook providers treat slow responses as failures. The handler can still run lightweight checks, but deeper ones, such as for prompt injection, belong in the run.
  • Treat the inbox as the source of truth: when woken, the worker pulls the latest events from it first, so a new worker can retry an event if one dies mid-run.
  • Allow only one active worker per inbox. Anthropic suggests starting with one inbox per user and splitting further only if you need more parallelism.
  • When a new event arrives mid-run, push it to the next run, fold it into the current run, or interrupt and restart.
  • Batch pending events, so several messages in a row get one reply.
  • Deduplicate events using the unique IDs their sources provide.

2. Timers

Together with the inbox, timers make the agent proactive. A follow-up is a deadline the agent sets for itself; a schedule is a recurring task on a known cadence, such as a daily newsletter. Timers live in their own durable store, usually another database table, because the inbox should only hold events that are ready to be worked on. A timer does not start a run on its own: a scheduler polls the store at a fixed interval, marks due follow-ups done, moves schedules to their next occurrence, then adds an event to the inbox and wakes the worker. You can build the scheduler yourself or use a durable execution engine.

3. Memory

Memory gives continuity across runs. Anthropic's own products implement it as a directory of files (Claude Code's auto memory and the Messages API memory tool); for an always-on agent that directory should live in a database or object store so it outlives the worker. The rule of thumb: store only what the agent cannot look up again, and save a pointer for anything that already lives in another system.

  • User instructions, in their own file, loaded at the start of every run.
  • User notes: role, preferences, corrections. Start with one file; as they grow, split into small files and load only an index, pulling files in when needed.
  • Past messages, so the agent does not repeat itself: either a separate file loaded every run, or the worker loads the agent's last few messages.
  • Task progress: one file per ongoing task covering what is done and what is left, again with only an index loaded at the start of each run.

Beyond memory saved during a run, the guide mentions dreaming: a separate pass that reviews past sessions to curate memories, replacing outdated entries and finding patterns that only show up across many runs.

Every run starts by loading the system prompt, tool definitions and memory files, so the guide recommends keeping that overhead lean and using prompt caching. A new session holds only that overhead plus the triggering events; an existing session also brings back its earlier messages and tool calls. When a session gets too long you can compact it or start a new one. Both lose detail, so anything that must persist should be saved to memory along the way.

4. Permissions

Anthropic calls this the riskiest part, because an unattended run holds the user's access. For each tool call the agent must decide whether to proceed, block it, or wait for approval. The recommended pieces: a credential proxy outside the agent's environment, so the agent sends requests without credentials and the proxy injects them; classifier-based review in the style of Claude Code's auto mode, which blocks actions it judges dangerous so the agent can find a safer approach, while the most important decisions still need user review; and deferred tool calls. In Claude Code a hook can defer a tool call: the run ends, the session is saved mid-call, the request is shown to the user (for example as an interactive card built with MCP Apps), and the answer arrives as a new inbox event that resumes the session. Meanwhile the worker can handle other events, so the agent is not blocked.

5. Outbox

A run ends one of three ways: the agent sends a message, decides nothing needs sending, or defers a tool call to ask for input. Most agents can get by with a simple send tool; you only need a formal outbox, a table plus a dispatcher service that decides what to deliver, when you want to pace messages or let the agent recover from errors. Anthropic recommends building evals to tune how often the agent speaks, and starting quiet.

A minimal build plan

The guide describes components, not code. Here is one possible mapping onto a relational database, with memory optionally in an object store. Everything in this section, including table names, columns, status values and intervals, is our illustrative sketch, not Anthropic's recommendation; adapt it to your own system.

-- Illustrative only: claudefox sketch, not from Anthropic's guide.
-- Column names and status values are examples.
inbox(id, user_id, source, source_event_id UNIQUE, payload, status, created_at)
timers(id, user_id, kind /* follow_up | schedule */, due_at, recurrence NULL, status, payload)
outbox(id, user_id, body, status, created_at)
-- memory: a directory of files per user in a database or object store
  • Handler (sketch): write the event, skip duplicates by the source's event ID, acknowledge quickly, wake the worker.
  • Worker (sketch): keep one active worker per inbox, pull the latest pending events, resume a session when an event continues earlier work, run the agent loop, mark events done.
  • Scheduler (sketch): at a fixed interval you choose, find due timers, update them, add an inbox event for each.
  • Dispatcher (sketch): read pending outbox messages, decide what to deliver under your pacing rule, deliver them.

Try it with your AI. Give this to your coding agent to plan an always-on version of an agent you already have (fill in the brackets first):

I have an existing agent in [repo path] that only runs when a user sends a message. I
want a plan for an always-on version using Anthropic's five primitives: event inbox,
timers, memory, permissions, outbox.
This is a planning task only: read the code, do not change code, do not run commands
that send network requests, do not run migrations, do not delete files.
1. List every place the agent is triggered today and every external tool it calls. For
   credentials, list only the type and where it is stored; never print credential
   values.
2. Propose inbox, timers and outbox tables for [database], including a unique key for
   deduplicating source events.
3. Propose a worker design: one active worker per inbox, batching of pending events,
   what to do when an event arrives mid-run (defer, fold in, or restart), and when to
   resume vs start a session.
4. Classify each tool call as automatic, blocked, or deferred for my approval, with a
   one-line risk reason. Default anything that spends money, sends messages or changes
   data to deferred. Credentials must stay outside the agent's environment.
5. Propose memory files (instructions, notes, past messages, task progress) and which
   are loaded every run.
Show me the plan as a short document and wait for my confirmation before doing anything
else.

Why now

Anthropic says always-on agents have become more practical because newer models judge better when to check in and because intelligence is getting cheaper, with long-horizon tasks benefiting most. Its example is specific: 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. That is one benchmark, not a general price cut.

FAQ

What is an always-on agent? An agent that keeps state across sessions and acts without direct supervision. In practice it sleeps most of the time and wakes for short runs started by inbox events, including timer events added by a scheduler.

What are the five primitives? Event inbox, timers, memory, permissions and outbox, wrapped around the same agent loop other agents use.

Does the guide require a dedicated Anthropic product? It does not announce one. It describes database tables, background services and files, and points to existing features such as prompt caching, compaction, the Messages API memory tool and Claude Code hooks; check their own documentation for availability and limits.

How does the agent ask for approval while unattended? With a deferred tool call: the run ends and the session is saved mid-call, the request is shown to the user, and the reply comes back as an inbox event that resumes the session.

Does a timer start a run directly? No. A scheduler polls the timer store at a fixed interval, updates due timers, adds an event to the inbox and wakes the worker.

What is dreaming in always-on agent memory? A pass that reviews past sessions to curate memories, replacing outdated entries and finding patterns that only show up across many runs.

When do I need a formal outbox instead of a send tool? Only when you want to pace the agent's messages or let it recover from errors; otherwise a send tool that delivers directly is usually enough.

Source: Building always-on agents (Anthropic, Claude resources)

This story first appeared in the claudefox daily briefing for November 16, 2026.