Always-On Agents Need Three Layers the Model Can’t Give Them
Last week Anthropic published Building always-on agents. It’s the clearest short description I’ve read of what it actually takes to run an AI agent that keeps working when nobody is watching it. If you’re building anything agentic, read it first and come back.
The key idea is that an always-on agent isn’t really always on. It sleeps. Something happens, it wakes for a run, does the work, saves what it learned and goes back to sleep. What makes it feel always on is the plumbing around the model: an event inbox, timers, memory, permissions and an outbox.
Reading it felt like reading our own design notes. Over the last few months a growing share of Black Grid’s delivery work for construction clients has been done by agents running on exactly this kind of plumbing. We built it in the Black Grid lab, broke it, rebuilt it, and ended up with three layers that do most of the heavy lifting.
I’m not publishing the code. But the shape of the solution, and the lessons that cost us something to learn, are worth sharing.
In January I wrote that the one AI skill that truly matters isn’t prompt engineering. This is what I meant.

The model isn’t the bottleneck any more
Anthropic makes the point that models are getting better at judging intent and much cheaper on long-running work. That matches what we see. When an agent fails on real work now, it’s rarely because the model wasn’t clever enough. It’s one of three much more boring problems:
- It forgot. It didn’t know what we decided last Tuesday, or it acted on something that stopped being true last month.
- It collided. Two agents (or an agent and a person) picked up the same job, or the agent acted on a situation that had already moved on.
- It improvised. It did the right task with the wrong recipe, when we already had a proven way of doing it.
Each of our three layers exists to stop one of these.
1. A memory layer you can correct (bg-mem)
The article describes memory as files in durable storage that outlive any single run, and gives some excellent advice: store only what the agent can’t look up again, and for everything else store a pointer. It also floats “dreaming”, a background process that reviews past sessions and tidies memory up.
We agree with all of it. bg-mem is our version, and it adds four rules we learned the hard way:
- Memory belongs to the business, not the model. bg-mem is self-hosted on our own hardware and shared by every agent and tool we use. Change models, change tools, and the memory stays. Nothing about what we know is locked inside one vendor’s chat history.
- One fact, one sentence, stored exactly as written. Each memory is a single short, self-contained statement. No summariser rewrites it on the way in, so nothing gets dropped or invented. Each one carries whether it has been verified, and verified facts win when two disagree.
- Correct it, don’t pile on. Stale memory is worse than no memory. An agent that confidently acts on last month’s truth does real damage. When something changes, the old fact is updated or retired in place, not left to argue with the new one.
- Remember where the evidence is. A good memory says what was decided and where the proof lives: the issue, the pull request, the file. Before an agent relies on a memory that names something, it checks that thing still exists.
The result is that when I ask an agent “what did we agree with that client about the cost codes?”, it doesn’t trawl my inbox. It recalls a one-line decision and the link to the evidence, and it knows whether that line has been checked.
2. A state machine for attention, not just an inbox (AOB)
This is the part of the article I’d underline twice. Every event source writes to a durable inbox. The inbox is the source of truth. Only one worker acts on it at a time. Events are de-duplicated and batched. When the agent needs a human, the run pauses and the answer comes back later as a new event. And the agent should start quiet and earn the right to interrupt you.
Our version is the Attention Outcome Board, or AOB. Every piece of work, whether it’s an email thread, a Slack conversation or a card I add by hand, becomes an item with three things: the trigger that started it, where it sits in our attention, and the after-state, a plain description of what done looks like. Items move through a small set of lanes: Inbox, Triage, Queued, Active, Waiting and Parked. People and agents work the same board with the same verbs.
An inbox tells you what arrived. A state machine tells you who owns it, what it’s waiting on and what finished looks like. That difference matters once you have more than one agent and more than one person. Here’s what we added:
- Claims are leases. An agent claims an item and gets a lease with a version number. It has to keep checking in. If it goes quiet the lease lapses and someone else can pick the item up, and a stale worker can never overwrite newer state. It’s the article’s “one worker per inbox”, applied to every item.
- Resync before you act. An inbox catches events. But in a real business the world changes without sending you one. A colleague drags a card on their phone, a client replies on the thread, someone leaves a comment. Before an agent claims, sends or closes anything, the board pulls in what changed. If a reply has arrived, the agent rereads it and updates the ask before it does anything else.
- Agents draft. People send. Nothing that leaves the building goes out on an agent’s say-so. Replies are drafted in the right thread, and a person reads and sends them. It’s the article’s “start quiet” advice taken one step further: the outbox is a human.
- Waiting is a real state. When work is blocked on a client, a colleague or me, it moves to Waiting with a reason. That’s the article’s deferred tool call, at the level of the business rather than the tool.
- Every closed item says how to resume. Which session did the work, where the files are and what’s left. Six weeks later, the next run (human or AI) starts warm.
3. An index of harnesses, so tool calling gets better over time (bg-exe)
The article warns that every run pays for the system prompt, tool definitions and memory, and that long sessions get compacted and lose detail. Its advice is to keep that fixed overhead lean. It also covers permissions: keep real credentials away from the agent, let classifiers stop risky actions, and keep humans on the important decisions.
The trap we fell into first was the giant system prompt. Every time an agent got something wrong, we added another paragraph of “here’s how we do X”. The prompt grew, the cost grew, and the agent still ignored half of it. The opposite trap is just as bad: an agent that improvises a procedure we perfected months ago.
bg-exe is our answer. It’s an index of how we do things: personas, reusable modules, task harnesses, references, tools and lessons, each one versioned. When an agent picks up a task it asks for the harness for this job and gets back the exact, approved revision, composed for the task rather than the whole library. It works the same whichever model is doing the work.
- One envelope for every actor. Whether the work is done by a person, an agent or both, it runs in the same execution envelope: plan, approval, execution, evidence.
- Approval is tied to an exact revision. A reviewer approves a specific version of the plan using a credential the autonomous agents never hold. Change the plan and the approval is revoked.
- Evidence, or it didn’t happen. Results are recorded with how we know they happened, and anything the agent merely reports is marked that way.
- Lessons get promoted, not appended. When a run teaches us something, it becomes a candidate revision. Once it’s reviewed and promoted, every future run gets it. The library gets better and the prompt doesn’t get longer.
That’s what I mean by super tool calling. The agent doesn’t reason from a blank page about which tools to use and in what order. It starts from a proven recipe and spends its intelligence on the part of the job that’s actually new.
How it fits together
Anthropic’s summary is that timers and events start a run, and the run reads memory, acts within its permissions, updates memory and writes to the outbox.
Ours reads almost the same. A trigger lands on AOB. The item is claimed under a lease. bg-mem supplies sourced context. bg-exe composes the harness and the envelope. The agent does the work, writes its result and evidence back to memory, and hands the item back to AOB, where a person approves anything that leaves the building. We proved that whole loop end to end, live, in early November.
Each layer is useful on its own. Together they turn “a clever chatbot” into something you can actually hand work to.
If you’re building this yourself
- Give work an owner and a definition of done before you give the agent more memory. Most “the agent got confused” problems are state problems.
- Make memory correctable from day one. You will be wrong about something. Plan for fixing it in place.
- Put people and agents on the same board. If humans work somewhere the agent can’t see, the agent will act on a world that no longer exists.
- Treat procedures as versioned assets. Don’t paste them into a prompt.
- Measure outcomes, not activity. An after-state reached is the only number that matters.
The models will keep getting smarter and cheaper. Anthropic’s own numbers say so. The advantage isn’t the model. It’s the layers you build around it and the domain knowledge you put into them. That was the message in January, and it’s truer now.
Stay curious, stay sceptical, and see you on the grid.
If you’d like to talk about putting this kind of agent workflow to work on your projects, get in touch with Black Grid.
Discussion
0 archived comments. New comments are not enabled.