O
OOMeta
← Back to Insights

September 2026 · 5 min read

Background agents need an inbox, not chat windows

Background agents need an inbox, not chat windows

Key Definitions

Background agent An agent that runs continuously or on a schedule without waiting for user input — nightly reconciliation, scheduled research, batch document processing. Unlike an interactive chat agent, the user is not present, so its output must be reviewed and decided on afterwards.

Inbox pattern A supervision interface that queues agent output into separate lanes — finished work (Unread) versus work waiting for a human decision (Action) — so the human returns to handle things rather than watching in real time. AWS open-sourced Pizza Bot as a self-hostable reference implementation on 2026-09-10.

Give an agent a task actually worth delegating and you will find yourself babysitting — watching a chat window scroll while it stops halfway, waiting for one approval. This week AWS open-sourced Pizza Bot (2026-09-10, Apache 2.0), turning “what background agents produce” into an inbox: finished work lands in Unread, work waiting for approval in Action. It looks like a small tool; it is actually a supervision pattern validated inside a big company: asynchronous agents need an asynchronous supervision surface. Supervision is queueing decisions, not watching logs.

Evidence: an agent interface built on outbox thinking

The AWS blog says it best: “You don’t send an email and then sit watching the outbox until the reply lands.” Pizza Bot is shaped like an email client for exactly that reason: a thread is a unit of work you come back to, not a session you have to attend. It began inside Amazon, where earlier versions were used by more than 2,000 people for meeting preparation, email drafting, Slack summaries, CRM logging, day prioritization, and web research, then rebuilt from the ground up as an open source project (AWS blog; sources at the end).

Architecturally it insists on “running where you can own it”: self-hosted, no telemetry; the server owns agent state and answers over HTTP, with desktop, browser, and terminal clients; runs are checkpointed, so quitting mid-run loses only the step in flight, not the whole thread. Model providers are your choice (Anthropic, Bedrock, Gemini, OpenAI, OpenRouter, even local Ollama); tools plug in via MCP; skills use the SKILL.md Markdown convention.

The two most valuable mechanisms are engineering-level: interruptOn is a per-tool approval policy — which tool calls must stop and wait for a human, with allowedDecisions setting the buttons you see; edit lets you correct an agent’s proposal instead of rejecting and rerunning from scratch. Installing an MCP server or plugin is an explicit decision — you confirm permissions before code runs.

Our judgment: asynchronous agents need asynchronous supervision surfaces

Chat assumes both parties are present: it holds for quick exchanges and breaks the moment a task runs for minutes or waits on your approval. The supervision surface for background and long-running agents must be “things you come back to,” not “processes you watch in real time.” Three design points are worth copying anywhere: first, separate output from pending decisions — queue “what the agent finished” (Unread) apart from “what the agent needs you to decide” (Action), so a returning human works by priority instead of digging through logs; second, make approval editable — correcting an agent’s proposal is cheaper than rerunning and closer to real collaboration; third, do not outsource supervision data — self-hosted, no telemetry, your own model, so output and approval records stay where you own them.

This is not theory for us. OOMeta’s daily cron pipeline is the same pattern: agents assemble signals into digest queues overnight, a human reviews and decides; batches with no change emit [SILENT] instead of noise. Unread/Action separation and our signal discipline are one principle — queue what needs a human decision, out of the noise. The larger your background-agent fleet, the more expensive this principle gets: every unsupervised asynchronous agent adds one more log nobody reads.

Implementation checklist: moving the inbox pattern into your background agents

① Redesign the output: every background agent produces a letter, not a log

A fixed letter structure: what it did, where the evidence is, who needs to decide what. If you cannot write “who needs to decide what,” the task is not yet broken down to a supervisable granularity.

② Define approval points: which tool calls get interruptOn

Low-risk actions run by default; high-risk actions stop and wait. Write approval policies per tool instead of handing the agent an all-access key.

③ Make correction a first-class operation: edit, not just reject

The value of supervision is minimizing the cost of a human correcting the agent. A reject-and-rerun-only surface pushes supervisors toward “fine, leave it.”

④ Draw the data boundary: let data leave only when needed

Self-hosting plus a local model (Ollama) is the default for sensitive-data workflows; move to hosted models only when data may leave.

Action: a two-week pilot that measures supervision cost

Pick one weekly workflow (nightly reconciliation, scheduled research briefs, batch document cleanup) and run it for two weeks with Pizza Bot or an equivalent inbox pattern, recording three numbers: how often human intervention was needed, how long each intervention decision took, and the share of agent output adopted without changes. The first number tells you how much automation is safe; the second tells you whether supervision itself is expensive; the third tells you whether agent quality has crossed the line.

The question for buyers: are your background agents “sending letters” or “rolling logs”? If the answer is the latter, the problem is not the agent — it is the supervision surface.

OOMeta AI

OOMeta’s daily operation is the inbox pattern in practice: overnight cron jobs assemble agent output into digest queues, a human reviews and decides; batches with no change emit [SILENT] instead of noise. Queueing what needs a human decision, out of the noise, is the core of our signal discipline — and our default principle when designing background-agent workflows for clients.

Book a diagnostic call

References: AWS Open Source Blog, “Introducing Pizza Bot, an open source inbox for AI agents that work in the background” (2026-09-10) https://aws.amazon.com/blogs/opensource/introducing-pizza-bot-an-open-source-inbox-for-ai-agents-that-work-in-the-background/ · Pizza Bot GitHub repository https://github.com/pizza-bot-app/pizza-bot

FAQ

What is Pizza Bot and who released it?+

AWS open-sourced Pizza Bot on 2026-09-10 under Apache 2.0: an email-style inbox for background agents — finished work lands in Unread, approvals in Action. It began inside Amazon (earlier versions used by 2,000+ people), runs on DeepAgents/LangGraph with MCP for tools (AWS blog).

What do the Unread and Action queues mean?+

Unread holds completed work you have not looked at; Action holds work paused, waiting for your approval or answer. The separation queues “what the agent finished” and “what the agent needs from you” apart — supervision becomes decision queueing instead of log-watching.

What are interruptOn and edit?+

interruptOn is a per-tool approval policy: it defines which tool calls must stop and wait for a human, and allowedDecisions sets the buttons you see. edit lets you correct an agent’s proposal instead of rejecting and rerunning — correcting is cheaper than restarting and closer to real collaboration.

Does my data leave my machine?+

Not by default. Pizza Bot is self-hosted with no telemetry, listens only on your machine until you say otherwise, and stores state in a folder you own. You choose the model provider — even a local model via Ollama. Installing an MCP server or plugin is an explicit decision, not a side effect.

How does this relate to how OOMeta operates agents?+

OOMeta’s daily operation is the same pattern: overnight cron jobs assemble agent output into digest queues, a human reviews and decides; batches with no change emit [SILENT] instead of noise. Unread/Action separation and our signal discipline are the same principle — queue what needs a human decision, out of the noise.