Skip to content
ISSUE 001·LIVE·20:20 IL
← Journal/2026-11-14·9 min·anthropic

Anthropic's always-on agents guide: the five primitives behind agents that never sit idle

Anthropic published a guide on building always-on agents: stateful, proactive agents that manage context across sessions. The core idea is that the agent is not actually running all the time - it sleeps between runs, and five architectural primitives decide when it wakes, what it remembers, and what reaches you.

By Harel Asaf·AI Builder·Tel Aviv

Anthropic published a guide this week called Building always-on agents, written by William Hu, and it is the clearest public blueprint I have seen from a model vendor for the architecture behind proactive agents. The guide makes one point early and keeps returning to it: an always-on agent is not actually always on. That is a description of the user experience, not the runtime. Underneath, the agent spends most of its time asleep, waking for short runs when something worth doing shows up. The continuity you perceive comes from the surrounding architecture, not from a model thinking around the clock.

Why now, per Anthropic: models got better at judgment, specifically at knowing when to check in with a user, and intelligence got cheaper where it matters most. On one long-horizon coding benchmark they cite, Opus 5.5 cost 78% less per solved task than Opus 5, compared with 40% less on typical workloads. Long-horizon tasks are exactly what always-on agents run, so the economics moved in their favor.

The cycle: sleep, run, save, repeat

Every unit of work is a run: the agent receives an event, completes its task, saves what happened, and goes back to sleep. A run happens inside a session, which is the transcript of messages and tool calls. Events that continue earlier work, like your reply to the agent, resume an existing session; everything else starts a new one. The cycle repeats indefinitely, and that indefinite cycle is the whole trick. Each run is brief. The loop is not.

The five primitives

The guide decomposes the surrounding architecture into five primitives: an event inbox, timers, memory, permissions, and an outbox.

#### 1. Event inbox

Most agents only run when you send a message. Always-on agents react to webhooks, scheduled tasks, and background jobs too. The naive design has each event source call the agent directly, which breaks two ways: simultaneous events start competing runs, and a crash loses events entirely.

The fix is an inbox between sources and the agent: a durable list of events (usually a database table), a handler that writes events to it (usually an HTTP endpoint), and a worker that reads from it. Best practices from the guide: the handler acknowledges fast and leaves deeper checks like prompt-injection screening for the run itself; the inbox is the source of truth, so a dead worker can be replaced and retried; only one active worker per inbox; and the worker batches pending events, so three rapid user messages become one run with one reply. Anthropic recommends starting with one inbox per user.

#### 2. Timers

Timers make the agent proactive rather than merely reactive. Two categories: follow-ups, which are deadlines the agent sets for itself (check whether the supplier replied by Thursday), and schedules, which are recurring tasks on a known cadence. They live in their own durable store, separate from the inbox, which should only hold events ready to work.

A timer never starts a run by itself. A scheduler polls the store at a fixed interval, and for anything due it marks a follow-up done, advances a schedule to its next occurrence, adds an event to the inbox, and wakes the worker. You can build that scheduler yourself or use a durable execution engine.

#### 3. Memory

Always-on agents work across disjointed runs, so memory carries continuity. It gets its own store, separate from inbox and timers. Anthropic points to its own products, Claude Code's auto memory and the Messages API's memory tool, which implement memory as a directory of files; for always-on agents those directories should map to durable storage so memories outlive the worker.

The rule of thumb: memory should only hold what the agent cannot look up again. For anything living in another system, save a pointer. Four memory types:

  • User instructions: saved in their own file, loaded at the start of every run, because you will not always be around to steer.
  • User notes: what the agent learned about you - role, preferences, corrections. One file to start, an index plus pullable files as it grows.
  • Past messages: what the agent already told you, so nothing repeats.
  • Task progress: per ongoing task, what is done and what is left, so a new run picks up where the last one stopped.

The guide also mentions dreaming: reviewing past sessions to curate memories, replacing outdated entries and finding patterns that only appear across many runs.

#### 4. Permissions

This is where the guide says always-on agents carry the most risk: a run holds your access and operates unattended by design. Three patterns:

  • Credential store: a proxy outside the agent's environment injects real credentials into outgoing requests. The agent sends requests without credentials; the proxy adds them before forwarding.
  • Auto mode: classifiers review higher-risk actions and block ones identified as dangerous, the same approach Claude Code uses. User review stays necessary for the most important decisions.
  • Deferred tool calls: when the agent needs clarification or approval, a hook defers the call, the run ends, and the session is saved until you respond.

#### 5. Outbox

Interactive agents stream everything as it happens. Always-on agents work in the background, so you get the outcome plus a few details. A run ends one of three ways: the agent sends a message to the outbox, it decides nothing needs sending, or it defers a tool call to ask you something.

A simple send tool covers most cases; a formal outbox, a table of outgoing messages plus a dispatcher service, matters when you want to pace messages or recover from errors. Anthropic's advice on volume: build evals to tune how much the agent says, start quiet, and earn the user's attention over time.

How it fits together

Every run starts with an event from the inbox, whether a user message, a webhook, or a timer. The worker kicks off a run in a new or existing session. The agent reads memory for a baseline, acts within its permissions, updates memory with what it learned, and pushes a row to the outbox. A run can set a timer that wakes the agent again later; your reply comes back as an inbox event. Brief runs, an endless cycle, and the feeling of an agent that never left.

One detail worth stealing for any implementation: the context window's initial overhead (system prompt, tool definitions, memory files) is paid on every run, so the guide recommends keeping it lean and using prompt caching to lower costs.

What I would take from it

My untested reading of the guide's center of gravity:

  • The inbox-as-source-of-truth pattern is the load-bearing idea. Everything else (retries, batching, one worker) follows from treating the inbox as durable truth rather than a queue you drain and forget.
  • The permissions section is short relative to its importance. If you build one thing carefully, build the credential proxy and the deferred-call path.
  • Start quiet is real product advice, not politeness. An agent that pings too much gets muted, and a muted always-on agent is worse than no agent.
  • The memory taxonomy maps cleanly onto how I would structure agent state: instructions, notes, said-already, progress.

What I would not conclude

Do not conclude Anthropic shipped a product here; this is an architecture guide, not a managed offering. Do not assume the five primitives require Anthropic infrastructure; the patterns are portable, though the guide naturally points at Claude Code and the Messages API as reference implementations. Do not read the Opus 5.5 cost figures as guarantees for your workload; they are one benchmark, vendor-reported. And do not treat dreaming as settled practice; the guide mentions it in one paragraph and points elsewhere for details.

Frequently asked questions

What is an always-on agent?

Per Anthropic's guide, a stateful, proactive agent that manages context across sessions and acts without direct supervision. It is not literally running all the time; it sleeps between short runs and wakes when an event, timer, or schedule gives it work.

What are the five primitives?

Event inbox (durable intake for webhooks, schedules, and messages), timers (follow-ups and recurring schedules), memory (files that outlive runs), permissions (credential proxy, auto mode, deferred tool calls), and outbox (delivery of outcomes to the user).

Why are always-on agents practical now?

Anthropic cites two drivers: better model judgment about when to check in, and cheaper intelligence on long-horizon work. Their cited figure: Opus 5.5 cost 78% less per solved task than Opus 5 on one long-horizon coding benchmark, versus 40% less on typical workloads.

Does the agent lose its memory when a run ends?

Runs end and sessions pause, but memory lives in its own durable store, usually a directory of files mapped to a database or object store. Each new run loads instructions and indexes first, then pulls detail files as needed.

How does the agent avoid spamming the user?

Through the outbox and deliberate volume tuning. A run can end without sending anything, and Anthropic recommends evals to find the right message cadence, starting quiet and earning attention over time.

Do I need Anthropic infrastructure to build this?

No. The guide's patterns (inbox tables, scheduler polls, memory files, credential proxies) are implementable on any stack. Anthropic naturally references its own primitives, like Claude Code's auto mode and the Messages API memory tool, as ready-made pieces.

What is dreaming in this context?

An optional memory process that reviews past sessions to curate memories, replacing stale entries and finding patterns visible only across many runs. The guide covers it briefly and links to a separate agent-memory post.

Sources

  • Building always-on agents | Claude by Anthropic - William Hu, November 13, 2026, read in full November 14, 2026. The sleep-run cycle, all five primitives with their best practices, the Opus 5.5 cost comparison, permissions patterns, and outbox guidance.

Not read: the separate Anthropic post on agent memory that the guide links for dreaming details. The cost figures are Anthropic's own from a single benchmark; I did not benchmark anything. This article summarizes a public guide; it is not an implementation report.

Related reading

The build log

Follow the work.

New essays and prototypes, in your feed reader. Email subscriptions are paused while I connect a working delivery service. No email is collected here.

Follow via RSS