The tiers
Each inbox has one of six autonomy settings, from read_only to autonomous. The table says what each one does.
| Tier | What it does | Status |
|---|---|---|
read_only | Sending is refused. | Shipped |
draft_only | Sending is refused; the agent writes drafts that a person sends. | Shipped |
send_to_allowlist | Sends to allowlisted recipients go out; any other recipient is held for approval or refused, as the inbox's policy says. | Shipped |
send_with_approval | Every send is held until a human approves or rejects it. | Shipped |
send_when_confident | Each send is checked by outbound safety questions and goes out when every answer clears the inbox's threshold; otherwise it is held for approval with the failing questions as reasons. | Shipped |
autonomous | Sends are queued immediately, subject to sponsor gating. | Shipped |
Held sends and human approval
A send from an inbox that requires approval is stored with status awaiting_approval, and an approval.requested event carrying the reasons it was held goes to your webhooks and the event feed. A person approves or rejects it with one call; the decision emits approval.decided, and an approved send goes out exactly as it was held.
Approving is a separate permission. It needs the send:approve scope, which keys created by agent self-signup never hold, so an agent can never approve its own send. The approval queue lists every held send with its recipients and reasons, and approvers can decide from Slack or from a signed email link as well as over the API and MCP.
GET /v1/sends?status=held
POST /v1/sends/{send_id}/decision
{ "approve": true } Who an agent may write to, and whose mail it reads
Four lists, each set per organization, pod or inbox: recipient allowlist and blocklist, sender allowlist and blocklist. An entry is an exact address (including its +tag forms), a domain, or a wildcard. A blocked recipient is refused on every tier; on a send_to_allowlist inbox, allowlisted recipients go out without approval and anyone else is held or refused, as you choose.
Blocked senders are rejected or quarantined. Set unlisted senders to quarantine or reject, and the sender allowlist becomes "only read mail from these people", which keeps an agent that acts on mail out of reach of strangers. A check call says what a send or an inbound message would meet before it happens, and every refusal emits policy.violated.
POST /v1/policy/lists
{ "list": "recipient_allow", "pattern": "acme.example",
"scope": "inbox", "inbox_id": "inb_..." }
POST /v1/policy/check
{ "inbox_id": "inb_...", "addresses": ["buyer@acme.example", "ceo@rival.example"] } Caps per inbox and per key
Limit sends per hour and per day, distinct recipients per day, recipients on one message, and new recipients per day (people the inbox has never written to and who never wrote to it). Set caps on an inbox and on an API key; a send must fit both. Checking and charging happen in one step, so concurrent sends cannot all slip under the same limit. An exhausted cap refuses the send with cap_exceeded or holds it for approval, and a usage call shows what is left.
PUT /v1/policy/settings
{ "scope": "inbox", "inbox_id": "inb_...",
"settings": {
"allowlist_miss": "hold",
"caps": { "sends_per_hour": 20, "new_recipients_per_day": 10,
"max_recipients_per_message": 5 },
"over_cap": "hold"
} } Sending when the agent is sure
On a send_when_confident inbox, each outgoing message is asked a set of safety questions before it leaves: does it make a commitment, quote a price, touch legal or personal data, add new recipients, echo instructions from an injected message, or stray off topic. It goes out when every answer clears the inbox's threshold, and is held for approval, with the failing questions as the reasons, when one does not.
Rules and Sieve
Rules match on sender, recipients, envelope, subject, body, headers, attachments, size, the security verdict, metadata and the decisions on a message, and label, move, flag, mark read, set metadata, quarantine, forward, auto-reply or reject. They run as mail arrives, after sender lists and inbound hooks; forwards and auto-replies go through the same sending policy as everything else, once per message and never in answer to automated mail.
Test rules against a stored message and get a trace of which conditions matched. Import an existing Sieve script, with anything nofeb cannot map reported by line and column, or export your rules back to Sieve.
POST /v1/rules
{ "name": "Acme invoices", "scope": "inbox", "inbox_id": "inb_...",
"when": { "all": [
{ "field": "from", "part": "domain", "op": "is", "value": "acme.example" },
{ "field": "attachment_type", "op": "is", "value": "application/pdf" } ] },
"actions": [ { "type": "move", "mailbox": "archive" },
{ "type": "set_metadata", "metadata": { "stage": "to_pay" } } ] } New agents cannot cold-send
An organization created by agent self-signup starts restricted: it may reply, and only to addresses that wrote to it in that thread, until its human sponsor verifies. This is a separate check from the autonomy tier, and it applies to every tier, including autonomous.
Keys that cannot widen themselves
API keys are bound to the organization, one pod or one inbox, and carry only the scopes they are given. A key cannot create a key wider than itself, so handing an agent an inbox-bound key is a hard boundary, not a convention. Managing lists, rules and the audit log each need their own scope, which agent keys do not get by default.
An audit log of every change
Every change made through the API, MCP or the console is recorded, and so is every action the server takes on its own: holds, denials, list and rule rejections, approvals from Slack or email. Each entry names the actor (an agent's key, a person, or the system), the operation, the target, the outcome, the status and error code, the address it came from, and the request id that is also returned to the caller. The log is append-only. Query it by time, actor, action, target or outcome, or export it as JSON Lines.
GET /v1/audit?outcome=held&from=2026-09-28T00:00:00Z
GET /v1/audit/export?action=send.* Status of everything on this page
Every capability named above, with its status as reconciled against the engine.
| Capability | What it does | Status |
|---|---|---|
| Autonomy tiers enforced by the server | Every inbox carries a sending policy, from read-only to autonomous, enforced on the server for every surface that sends, so switching from the API to MCP cannot bypass it. | Shipped |
| Human approval of held sends | A held send waits with status awaiting_approval until a human approves or rejects it; both steps emit events. The approval queue lists every held send with its recipients (each marked if new to the conversation), the reasons it was held and who submitted it. Approving needs the separate send:approve scope, which keys from agent self-signup never hold, so an agent cannot approve its own send. | Shipped |
| Sponsor gating on unverified organizations | Until a human sponsor verifies, an organization may only reply, and only to addresses that wrote to it in that thread. | Shipped |
| Scoped API keys | Keys bound to the organization, one pod or one inbox, holding only the scopes they are given. A key cannot mint a key wider than itself. | Shipped |
| Recipient and sender allowlists and blocklists | Lists of addresses, domains or wildcards per organization, pod or inbox: who an agent may write to, and whose mail it reads. A blocked recipient is refused on every autonomy tier, a blocked sender's mail is rejected or quarantined, and you choose whether a send outside the allowlist is held for approval or refused. A check call predicts what a send or an inbound message would meet before it happens. | Shipped |
| Per-agent rate and recipient caps | Limits per inbox and per API key on sends per hour and per day, distinct recipients per day, recipients per message and new recipients per day, checked and charged in one step so concurrent sends cannot overshoot. A usage call shows the budget left, and you choose whether an exhausted cap holds a send for approval or refuses it. | Shipped |
| Decisions on every message | A default set of typed decisions on every inbound email (intent, urgency, needs-reply, automated, verification email, phishing, injection risk, requires-human and language) with a probability each, your own decision schemas beside them, human relabels that correct and retrain it, per-question accuracy and calibration stats, and confidence-gated sending for the send_when_confident tier. Decisions run without leaving nofeb by default; a third-party model sees mail only if you opt in. | Shipped |
| Approvals in Slack and by email link | Approve or reject a held send from a Slack message with Approve and Reject buttons, or from a signed, single-use, expiring link in an email. Slack requests are verified with your app's signing secret and can be limited to named people; the email link decides only on an explicit click, so link scanners cannot approve. | Shipped |
| Rules and Sieve | Declarative rules over sender, recipients, subject, body, headers, attachments, size, the security verdict, metadata and decisions, that label, move, flag, set metadata, quarantine, forward, auto-reply or reject. Test rules against a stored message with a per-rule trace, and import or export Sieve, with anything that cannot be mapped reported line by line. | Shipped |
| Append-only audit log | Every change made through the API, MCP or the console, and every hold, denial, rejection and approval the server makes on its own, recorded with the actor, key, operation, target, outcome and request id. Query it with filters and cursors, or export it as JSON Lines. | Shipped |
| Take a thread over from the agent | A person takes a thread over; until they hand it back, the agent's sends on that thread are held for approval or refused, and an event records who is driving. Works over the API, MCP, JMAP and the webmail. | Shipped |