Published: 2026-11-16
Summary

Anthropic's always-on agent guide in five pieces: an inbox, timers, memory, permissions and an outbox

Chapters / key moments (click to jump — plays here on the page)

The idea: an "always-on" agent spends most of its time asleep. An event arrives, it wakes, does one short run, writes down what happened and goes back to sleep. Anthropic's guide breaks that loop into five pieces, and this video walks through them. We read the guide itself and checked each claim below against it.

Source video

"Anthropic Just Explained How to Build Always-On Agents (Master It In 10 Minutes)" by Bart Slodyczka — Watch on YouTube → The video explains Anthropic's "Building always-on agents" (dated 13 November 2026); the guide-checked points below are marked as such. The video shows no build and no commands.

The five pieces

  1. Event inbox. A durable store that every event source writes to (a new email, a message from you, a payment) and a worker reads from. Per the guide, the handler should acknowledge events quickly, the inbox is the source of truth, events are deduplicated by their source identifiers, and you can start with one inbox per user. The video's reason for not letting everything call the agent directly: two events at once would give you two copies of the agent working over each other, and a crash would lose the job.
  2. Timers. Two kinds: a follow-up the agent sets for itself ("check back Thursday if the client hasn't replied") and a schedule that repeats ("a summary every morning at 8:00"). The guide keeps them in their own store that a scheduler polls at a fixed interval, and notes that a timer does not start a run by itself: when one is due it puts an event in the inbox.
  3. Memory. The guide's rule: memory should only hold what the agent can't look up again, so if the information lives in another system, store a pointer instead. It lists user instructions, notes about the user, past messages and task progress. The video adds that the agent should read a short index first and open details only when needed, and describes "dreaming", tidying memory between jobs; that last idea is the video's description and we did not find it in the guide.
  4. Permissions. Per the guide: keep credentials out of the agent's environment behind a proxy that adds the real credentials to each request; use auto mode, where classifiers review higher-risk actions and block dangerous ones, and keep a human in the loop for the most important decisions; and for questions to the user use a deferred tool call, which ends the run and saves the session mid-call, so the answer returns as an inbox event that resumes it.
  5. Outbox. Where outgoing messages go, with a dispatcher that delivers them. The guide says a formal outbox is only needed to pace messages or recover from errors; otherwise a plain "send" tool may do. Its advice on volume: start quiet and earn more of the user's attention over time, and build evals to find the right message count.

One worker per inbox, and what to do with a message that arrives mid-run

The guide's rule is that an inbox should only have one active worker at a time. When something new lands during a run, it names three options, and the video repeats them: push it to the next run, fold it into the current run, or interrupt and restart with everything together. The video suggests folding in for a chat assistant, because you get one reply that covers everything you said.

Cost: keep the starting pack small

  • Every wake-up loads the same starting context (instructions, tools, memory files), so keep it lean and use prompt caching. The video calls this the "starting pack"; the guide's wording is keeping the initial context lean.
  • For a long conversation you can compact the old part or start a fresh session. The guide says both approaches lose detail, so anything that must persist should be saved to memory as you go, not left in the chat.
  • The video and the guide both give one number: on a long-horizon coding benchmark, Opus 5.5 cost 78% less per solved task than Opus 5. The guide adds 40% less on typical workloads.

The worked example: an invoice-chasing agent

The video's illustration, which is a good template to copy: an 8:00 timer drops a job in the inbox and the agent wakes and reads its notes (be polite, never chase anyone more than once a week, always ask before contacting a big client; three overdue invoices, one emailed on Monday). It skips the Monday contact, sends a friendly reminder to the second, and for the third, a big client, asks you through the outbox instead. It sets a Thursday follow-up timer, updates its notes and sleeps. Your "yes" at lunchtime arrives as a new inbox event, the agent resumes where it stopped, sends the email and records it. The video says the whole morning run took under a minute.

A minimal rebuild checklist

Our reading of the guide, not a procedure it gives.

  • One inbox per user, and one worker that drains it; every trigger (email, chat reply, timer, payment) writes an event there instead of calling the agent.
  • A separate timer list with follow-ups and schedules, polled on an interval, that only writes events.
  • A short instructions file and an index of notes the agent reads at the start of every run; store pointers, not copies, of anything it can look up.
  • Credentials behind a proxy, a list of actions that can run unattended, and a deferred "ask the user" step for the rest.
  • A way to send messages, with a quiet default.

Caveats

  • This is an architecture talk. It names the pieces and shows one imagined example, not a working build, a file layout or a command.
  • The video's mistakes to avoid: do not let the agent message you about everything (past around ten notifications a day you stop reading them), and do not give the agent real passwords or more access than the job needs.
  • The video does not say which product to build on; the pattern applies to any agent runtime.