Glossary

PracticeAgents & Tool Use

Always-On Agents

At a glance

Stateful, proactive agents that wake on events, carry working state between short runs, and sleep until the next event.

Who this is for
Engineers and technical readers learning the terms used in AI systems.
Topics
  • Agents & Tool Use
  • Practice

In short

Always-on agents keep state across short event-triggered runs and act while nobody is sitting in the session. They sleep between those runs rather than spinning forever. Bigcircle ships the same controls under AI agent permissions, agent memory, a kill switch on the request path, and loop engineering, rather than under a product named always-on agents.

Key facts

Definition

An always-on agent is a stateful, proactive agent that wakes on events, carries working state between short runs, and acts while nobody is watching the session, then sleeps until the next event.

How Bigcircle does it

  1. Bigcircle sets AI agent permissions one action at a time, with the authorization check in code and credentials in a vault the model never sees, which is the same permission shape an unattended always-on run needs.
  2. On Solarpunk, Bigcircle carries context between runs with local retrieval and planner memory, and measured plans completed with no human intervention rising from about 55% to 80% once that was in place.
  3. Bigcircle puts a spend and turn cap on the request path and an AI agent kill switch a named person can flip before the next model or tool call, fail-closed if the control plane cannot be read.

Comparison

A chat agent runs when a person messages it and streams every step back. An always-on agent also wakes on webhooks, schedules and follow-ups, keeps memory across sessions, and returns a paced outcome rather than the live trail.

Key number

On Solarpunk, plans completed with no human intervention rose from about 55% to 80% after local retrieval and planner memory grounded the agent, without changing its authority.

Always-on agents keep working after the chat window closes, and they do that while nobody is sitting in the session. They pick up a webhook, a due follow-up or a later reply, and they remember what they already finished. The phrase spread among builders after Anthropic published Building always-on agents on 13 November 2026.

The name does not mean a model is left running all day waiting for work. An event starts a short run, the run writes what it learned, and then the process waits until the next event. Treat always on agents as that idle-and-wake cycle, not as a model left spinning overnight.

What is an always-on agent?#

An always-on agent keeps working state across many short runs and starts those runs without waiting for a person to type. A chat agent answers when someone messages it. An always-on agent also reacts to webhooks, schedules, follow-ups and other background events, then decides whether to message you, ask for approval, or stay silent.

The continuity sits outside any one transcript. Memory holds instructions, notes, past messages and task progress that the next run can load. Permissions decide which tool calls may proceed alone, which wait for a person, and which are refused. Without those pieces, a "proactive" agent is just a cron job that can invent work and spend.

Those controls are not a new product we sell, and they already show up in how we ship agents. Agents act through MCP tools, and credentials stay outside the model so a run cannot print them. A stop sits on the request path, and memory lasts only when the work recurs.

event inboxtimersoutboxuserdeduped eventsfollow-ups, schedulespaced deliveryor silenceshort runthen sleeploaded every run, outside what a single transcript can holdmemory storepermissions / approvalscredential proxyinstructions, notes, progressproceed, defer, or refusesecrets never in the model

Always-on agent architecture: the five primitives#

Leave an agent unattended and five pieces have to exist outside the model. Skip any one and you later lose a webhook, run the same job twice, repeat a message, or write something nobody approved. Those pieces are an event inbox, timers, memory, permissions and an outbox.

Event inbox#

A webhook provider that calls the agent directly will retry on a slow ack, and two events arriving together will start two runs. Put every trigger into one queue the operator can inspect: webhooks, user replies, due timers and background jobs. Deduplicate by the source's own id so a retry does not start a second run.

Keep one worker reading that queue, so two runs do not race on the same user's files or tickets. A reply that belongs to an open task should reopen that session; a new trigger should start a fresh one. If a worker dies halfway through, the next one should read whatever is still unmarked in the queue.

Timers#

Follow-ups wait for a reply that may never come, such as checking whether a person answered. Schedules fire on a known cadence, such as a weekly digest. Store both separately from ready work, because a Tuesday job should not sit in the inbox until Tuesday.

A scheduler marks due items and inserts an inbox event, so the agent starts the same way it would for a webhook. That keeps follow-ups and cadences without leaving a process spinning all day. The agent still wakes through the inbox, and that queue is where you debug a follow-up that fires twice.

Memory#

Each run is short and the worker can die, so memory has to outlive that worker. The next run still needs standing instructions, notes about the user, what it already said, and where the task left off. Load the instructions at the start of every run, because the person will not be there to repeat them.

If the fact already lives in another system, store a pointer rather than a copy. Before you compact a long session or start a new one, write down anything the next run cannot afford to lose. That matches what we already write on agent memory.

Permissions#

Once nobody is watching the session, the agent is still acting with that person's access, and that is how an unapproved write gets through. Decide per tool call whether to proceed, block, or wait for a person. If a write needs a person, end the run and treat their answer as the next inbox event.

Our guide on AI agent permissions puts that check in code at the tool layer, against the person who asked, the target and its current state, with the credential attached where the model cannot read it.

Outbox#

Chat agents stream every step because someone is watching the transcript. An unattended run should not do that, because the person is usually elsewhere when the work finishes. Queue outbound messages so a failed send can retry, and so you can throttle an agent that starts pinging too often.

Flood the user and they mute the agent; stay silent and they miss a result they needed. That balance belongs in the outbox, not in a side-channel send from inside the model call. Put delivery on its own queue so you can retry a failed send without starting the run again.

Where did always-on agents come from?#

Anthropic published Building always-on agents on 13 November 2026, written by William Hu. That article is the origin of the phrase as builders are using it this month: the sleep/wake cycle, the five primitives, and the claim that "always on" names the experience rather than a constantly running process.

Builder posts on X the same week mostly restated those pieces rather than inventing a second definition. @johnmatechAI put the product point in one line: "The most important thing an always-on agent does is decide not to message you." @pggalaviz listed the parts that matched years of distributed systems and background workers: inbox first, one active worker, fast webhook acks, dedupe by source id, pointers in memory, credentials in a proxy, and a quiet default.

@andy__geee compressed the architecture to "event inboxes, memory stores, timers, permissions layers." @AKSaathwik wrote the approval rule as anything that sends, posts, deletes or spends waiting for a person. @GilsGarage took the skeptic cut: the interesting part is still webhooks and cron jobs under a new name.

We keep those posts as readings of the Anthropic checklist, not as a standards document. The architecture is familiar. The new demand is leaving it unattended without losing events or flooding a person.

How Bigcircle handles always-on agents#

We have not shipped a product called always-on agents. The controls the phrase needs already sit in how we build agents, under older names.

AI agent development starts from the job, the tools it touches, and the points where a wrong action is expensive to undo. Agents plan through MCP tools, stop a bad action in a policy check before it runs, and finish only after a separate read matches the expected state. A human checkpoint stays wherever the stakes justify one. That is the same shape as an always-on run that may proceed, defer or refuse.

Agent orchestration covers the case where one agent is no longer enough: a supervisor, workers with their own tool scopes, and one trace across the whole run. An always-on system that fans work across specialists still needs that supervisor and that trace, or a failure becomes a mystery instead of a step.

On permissions, we set AI agent permissions one action at a time, for one workflow, with the authorization check in code and credentials in a vault or broker the model never sees. On Solarpunk, credentials stay in an encrypted vault on the user's machine. On Skionis, the agent reaches a live AWS account only through purpose-built tools.

An always-on agent that wakes on a webhook gets the same treatment: the event may start the run, but the tool still decides whether the write happens.

Agent memory is how state survives once a task outgrows the context window. We persist what is slow to rediscover, recompute what one tool call can refresh, and add memory that lasts across sessions only when the workflow recurs. On the executive operations agent, local retrieval and planner memory carried context between runs, and plans completed with no human intervention rose from about 55% to 80% once that was in place.

Cost and stop conditions matter more once nobody is watching every turn. Our AI agent cost guide splits the bill into build, run and keep-alive, and puts a cap that ends a runaway loop before the next paid call.

An AI agent kill switch is a flag a named person can flip on the request path, checked before the next model call and the next tool call, fail-closed if the control plane cannot be read. Prefer a writes-disabled or one-tool stop before a global halt.

Loop engineering is the layer that makes event-triggered runs safe: a verification check the agent cannot edit, a run cap, and triggers that start work when something happens. Goal engineering sits above that loop. Write what finished looks like, how a person reviews it, and what the agent may not do, before you leave the agent waking itself on a schedule.

Skip a full always-on architecture while the work is still a short workflow with steps you can write down, or while a person already watches every run. Put the permission check, the memory rule and the kill switch in place first. The inbox and the timers only earn their keep once a run can finish safely with nobody watching.

Common questions about always-on agents

  • What is an always-on agent?

    A stateful, proactive agent that keeps working state across short runs and starts those runs from events, not only from a person typing. It wakes, does the work, writes what it learned, and sleeps until the next event.

  • Are always-on agents actually always on?

    No. Nothing is left running overnight waiting for work. An event starts a short run, that run writes what happened, and the process sits idle until the next event arrives.

  • What is always-on agent architecture?

    Five pieces sit around the agent: an event inbox, timers, memory, permissions and an outbox. Triggers land in the inbox, due timers become inbox events, memory carries state between runs, permissions bound each tool call, and the outbox decides what reaches the person.

  • How do always-on agents differ from a chat agent?

    A chat agent mainly runs when a person sends a message and streams the work live. An always-on agent also starts from webhooks, schedules and follow-ups, keeps memory across sessions, and often returns only the outcome rather than every intermediate step.

Let's build something that ships.

Tell us what you're building. We'll tell you whether it needs a fixed-scope build, a prototype taken to production, or a programme we run, what's achievable, and where the real bottlenecks are.

Reply within 2h

We store your name, email, company, and message, and email a copy to hello@bigcircle.ai. Read the privacy page and the terms.