Anthropic's Always-On Agent Design Puts Permissions at the Center of Risk
Anthropic's new architecture guide for always-on agents reveals where unattended AI actually breaks: not the model's intelligence, but the plumbing that decides when it acts and who approves what.
Independent UpShaqo analysis built from fresh, attributed sources. We explain the impact instead of repeating the announcement.
Read for leverage: focus on the workflow change, the customer problem, and the next action—not only the product announcement.
A founder weighing whether to let an agent handle overnight customer follow-ups, chase unpaid invoices, or monitor a shared inbox without a human reviewing every step faces a narrower question than it first appears. It isn't whether the underlying model is capable enough. It's whether the system wrapped around that model knows when to wake up, what to remember between sessions, and — critically — when to stop and ask permission before it touches something that matters.
Anthropic's new engineering guide on building always-on agents answers that question with unusual specificity. Rather than pitching a feature, it lays out the architecture required to run an agent that persists across sessions, acts without direct supervision, and decides for itself when to re-engage a human. For operators evaluating whether to deploy this class of system, the document functions less like marketing and more like a risk map.
What "Always-On" Actually Means
The guide is careful to puncture its own premise early: an always-on agent is not actually always on. It spends most of its existence asleep, waking periodically to complete a bounded unit of work called a run, then saving what happened and going dormant again. That cycle — wake, act, record, sleep — repeats indefinitely, and the repetition is what creates the illusion of continuous presence. This is a useful corrective for buyers who may imagine a single persistent process reasoning continuously. In reality, according to Anthropic, the system is a sequence of short, discrete executions stitched together by infrastructure most vendors don't discuss publicly.
Anthropic attributes the renewed interest in this pattern to model improvements — better judgment about when to check in with a human, and sharply falling costs on long-horizon tasks. The company cites one internal benchmark where its Opus 5.5 model cost 78% less per solved task than its predecessor on long-horizon coding work, compared with a 40% reduction on typical workloads. That figure is Anthropic's own benchmark result, not an independently verified industry statistic, and it should be read as evidence of Anthropic's economics rather than a universal claim about agent costs generally.
The Five Primitives, and Where the Risk Concentrates
Anthropic's architecture rests on five components: an event inbox, timers, memory, permissions, and an outbox. The inbox queues triggers — webhooks, scheduled jobs, user replies — so that competing events don't start duplicate runs or get lost in a crash. Timers handle proactivity, distinguishing between self-set follow-ups and recurring schedules. Memory persists what the agent has learned across sessions, split into user instructions, notes about the user, past messages, and task progress, with only summaries loaded by default to keep context lean. The outbox paces outgoing messages so the agent doesn't flood the user or go silent for too long.
Four of these five primitives are primarily engineering concerns: get them wrong and the agent is clumsy, slow, or forgetful. The fifth — permissions — is where Anthropic itself says the agent "carries the most risk," because a run operates with the user's actual access and, by design, without someone watching in real time. That's the primitive worth scrutinizing before any deployment decision.
The Permissions Problem in Practice
Consider a sales operations team that wants an agent monitoring a CRM, drafting follow-up emails, and occasionally updating deal stages overnight. Anthropic's recommended pattern routes credentials through a proxy outside the agent's own environment, so the agent never directly holds passwords or tokens — it sends bare requests and the proxy injects real credentials before forwarding them. For higher-risk actions, an "auto mode" layer of classifiers reviews what the agent wants to do and blocks anything flagged as dangerous, forcing the agent to find a safer path. For the highest-stakes decisions — sending a contract, closing a deal, deleting a record — the system can defer the tool call entirely, pause the session, and wait for a human to approve via an interactive prompt before resuming.
This is a meaningful design choice: it means the agent's autonomy is not binary. It can act freely on low-risk steps, get algorithmically screened on medium-risk ones, and get fully blocked pending human sign-off on the rest. The tradeoff is that this tiering only works if the classifiers and escalation rules are tuned correctly for the specific business — a generic threshold will either over-block routine work or under-block something that matters.
Anthropic's companion announcement on Claude Sheets, Whiteboards, and upgraded interactive connectors gives a sense of what enterprise-grade guardrails look like around this kind of access: admins setting granular spend limits, audit logs feeding a Compliance API tied to tools like Splunk and CrowdStrike, and each cloud session running in its own isolated virtual machine with connector credentials kept outside it. None of that is specific to always-on agents, but it's the kind of scaffolding that makes unattended, credentialed agent activity auditable after the fact — which matters once an agent is acting while no one is watching.
Evidence Versus Speculation
What's documented: the five-primitive architecture, the deferred-call pattern for human approval, the credential-proxy design, and the cost benchmark Anthropic reports for Opus 5.5. What's not documented: how reliably the auto-mode classifiers actually catch dangerous actions in production, what failure rates look like when an always-on agent misjudges urgency, or how this pattern performs outside Anthropic's own tooling. The guide is a design blueprint, not a track record. Treat claims about judgment and reliability as Anthropic's stated intent until third-party deployments produce independent data.
Controls Worth Insisting On
For teams evaluating an always-on deployment, a few non-negotiables emerge directly from the architecture itself:
- Require that credentials live in a proxy layer the agent never directly accesses, not embedded in the agent's own environment.
- Insist on a documented escalation path for deferred tool calls — know exactly which categories of action require human approval before go-live, not after an incident.
- Build evals specifically for outbox tuning; an agent that under-communicates can bury a real problem as easily as an over-communicating one creates noise fatigue.
- Ask vendors whether memory stores are durable and auditable independent of the worker process, since memory loss between runs breaks continuity silently.
What Remains Unresolved
Anthropic's guide doesn't address liability when an auto-mode classifier wrongly approves a harmful action, nor does it specify default thresholds for what counts as "higher-risk." It also doesn't say how this architecture holds up under adversarial conditions — prompt injection delivered through a webhook event, for instance, is acknowledged as a risk to screen for during a run, but the guide offers no concrete detection method. Buyers should treat always-on agents as a credentialed, semi-autonomous system requiring the same security review as any new employee with standing access — not as a feature toggle.