Building always-on agents news update: Anthropic outlined an architectural

Anthropic outlined an architectural blueprint for deploying proactive artificial intelligence systems in Claude Blog's report on autonomous software patterns. The analysis highlights that these persistent tools stem from sharp efficiency gains in advanced models. On one long-horizon coding benchmark, Opus 5.5 reduced the cost per solved task by 78 percent compared to Opus 5, outperforming the 40 percent savings seen on typical workloads.

This operational breakdown details the structural primitives required to operate stateful, unattended assistants that process background events reliably without continuous supervision. Engineering teams evaluating persistent agent workflows will learn how decoupled storage components, queue workers, and safety controls replace fragile real-time invocation loops.

01Execution cycles across intermittent sleeping runs

An always-on agent does not run continuously in active memory despite what the naming suggests. The system spends most of its time asleep, waking intermittently to execute defined stretches of work called runs. Each run operates inside a session that records messages and tool calls before saving state and returning to sleep.

The foundational loop of an always-on agent matches traditional reactive assistants by processing events and executing tool calls. Modern models unlock this behavior through improved judgment, accurately interpreting user intent and discerning when to check in. Lower inference costs enable sustained task execution across extended horizons without inflating production operational budgets.

Coordinating this cycle requires five specific architectural primitives rather than direct code wrappers. These elements include an event inbox, persistent timers, structured memory, credentialed permissions, and a message outbox. Managing these five components ensures an assistant preserves state across disjointed sessions, retains operational guidelines, and interfaces safely with external services.

02Durable event queues and single workers

Routing webhooks, background jobs, and user triggers directly into an agent causes race conditions and risks lost data during crashes. Production setups resolve this fragility by placing a durable relational database table between incoming event sources and active compute workers. An HTTP handler writes incoming records to this queue, assigns unique deduplication identifiers, and wakes a background worker.

Fast acknowledgement at the HTTP boundary prevents external providers from treating slow responses as delivery failures. Inbound handlers run only lightweight validation while deferring deep checks, such as prompt injection detection, to the actual runtime execution. This separation of concerns preserves endpoint responsiveness and maintains a clean boundary between transport ingestion and model reasoning.

Database tables serve as the definitive source of truth so interrupted tasks resume cleanly if background services fail mid-run. Restricting each inbox to a single active worker prevents competing processes from overwriting shared conversational state. When multiple triggers arrive concurrently, the assigned worker merges pending events into a unified batch so the agent responds once.

03Scheduled cadences and self-directed follow-ups

Proactive agents depend on dedicated timer registries to initiate actions independently without waiting for immediate user prompts. Timers reside in an independent durable database table separate from active inbox events awaiting immediate execution. This physical separation prevents pending chronological triggers from clogging operational queues that handle real-time webhook payloads and user messages.

Temporal triggers divide into two distinct functional categories: follow-up deadlines and recurring schedules. A follow-up represents an internal deadline the agent designates for itself, such as checking whether a user responded to an inquiry. A recurring schedule operates on a fixed cadence, such as compiling and distributing an automated daily newsletter to subscribers.

Background schedulers or durable execution engines poll the timer database at steady intervals to identify due entries. Once a deadline elapses, the scheduler marks one-off follow-ups as completed and advances recurring schedules to their subsequent execution timestamp. The scheduler then appends an event to the inbox and wakes the worker to process the run.

04Persistent file stores and memory dreaming

Agents operating across disjointed runs rely on durable file directories to preserve vital context across system restarts. Mirroring storage patterns used in Claude Code auto memory and the Messages API memory tool, these files map to external databases or object stores. System memory stores only facts the agent cannot look up again, substituting pointers for items in issue trackers.

Persistent storage organizes into separate files covering user instructions, behavioral notes, past messages, and task progress tracking. Core instructions load at the start of every run to steer unattended choices. Detailed user notes and active project milestones rely on indexed overview files, allowing the agent to pull granular text into context only when needed.

Retaining copies of past conversational turns prevents the model from generating redundant remarks across successive runs. Beyond standard runtime saves, offline dreaming routines review historical session transcripts to curate stored memories during idle periods. Dreaming replaces obsolete records with current facts and identifies systemic behavioral patterns across multiple historical interactions that single-run workflows miss.

05Lean context caching and unattended permissions

Every execution run incurs a fixed context overhead from loading system prompts, tool definitions, and memory files. Systems manage operating expenses by keeping initial context lean and using prompt caching across recurring definitions. Existing sessions restore preceding transcripts and tool calls directly, while new sessions launch with only the baseline context overhead and the triggering event payload.

Extended sessions require proactive context management through message compaction or clean session resets to avoid window limits. Because aggressive summarization inevitably discards granular discussion details, critical insights and task outcomes must be committed to durable memory files during the run. This continuous recording strategy ensures that essential operational state survives across transcript compaction boundaries and restarts.

Unattended agent execution introduces operational risks because background workers possess access privileges without an operator actively watching each action. Models must evaluate every tool invocation to decide whether to proceed autonomously, block the action, or pause for approval. Sensitive passwords and programmatic access tokens require dedicated credential stores to keep authorization secrets insulated from exposure during reasoning loops.