Skip to content
intermac
Journal
Engineering

3 min read

Always-on agents: permissions are the hard part

Anthropic's guide to always-on agent architecture covers mostly familiar distributed-systems patterns — except for permissions, where the risk profile changes fundamentally.

By intermac

The five primitives Anthropic lays out in their guide to building always-on agents — event inbox, timers, memory, permissions, outbox — will look familiar to anyone who has built event-driven systems. That's intentional, and it's also the trap.

Most of the architecture is recoverable. Lose a message from the inbox, you retry. Compact an overlong session and lose some detail — the agent keeps working. These are the failure modes you already manage in any background job system.

Permissions are different. In an always-on agent, a run holds the user's actual access and operates without supervision. When a synchronous agent makes a bad call, the user is there to catch it. When an always-on agent makes the same call at 3am triggered by a webhook, the damage is done before anyone sees it.

Anthropic's recommended pattern — a credential proxy that injects credentials outside the agent's environment, classifiers to flag higher-risk actions, and deferred tool calls for decisions requiring explicit approval — is the right instinct. But the guide also notes that user review is still necessary for the most important decisions. The question for builders is which decisions those are, and how you enumerate them before you ship.

We'd push further than the guide does here: scope the tool set aggressively from the start. An agent that can read and summarize is much safer than one that can also write and send. The guide recommends starting agents quiet — biased toward doing less — and letting them earn more autonomy over time. That's right for output volume, but the same logic applies to capability scope. You can always add tools; you can't unsend a batch of emails.

The familiar parts are a gift

The event inbox pattern — durable table, HTTP handler, background worker — is straight distributed systems. Teams that have run job queues will implement it quickly. Timers follow the same logic: a scheduler polls a store and fires events when they're due. That familiarity frees up attention for the genuinely novel problems: maintaining continuity across disjointed runs, knowing when to interrupt the user versus decide independently, handling ambiguous situations with no one available to ask.

Memory is worth reading closely

The memory model in the guide is more considered than the typical "vector store everything" approach. Separate stores for user instructions, user notes, past messages, and task progress — with only an index loaded at the start of each run — keeps context overhead manageable. The underlying principle is worth internalizing: memory should only hold what the agent can't look up again. If the data lives in another system, store a pointer.

Always-on agents are going to become a standard product primitive. The teams that get there safely will treat the permissions layer with the same rigor they'd apply to any system that acts on users' behalf without supervision.

Sources

Tags

  • #agents
  • #architecture
  • #permissions
  • #distributed-systems