Skip to content
nofeb

Product / Governance and autonomy

Autonomy tiers the server enforces

A tool list is not a permission system. If an agent holds a credential that can send, leaving the send tool out of its prompt does not stop it. nofeb puts the policy on the inbox and enforces it where mail is submitted, so it holds whichever interface the agent uses: REST, MCP, JMAP or SMTP.

The tiers

Each inbox has one of six autonomy settings, from read_only to autonomous. The table says what each one does.

Autonomy tiers and the approval flow A ladder of the 6 autonomy tiers from autonomous at the top to read_only at the bottom, each with the status of what it depends on. Beside it, a send from any surface is checked against the inbox's tier, its recipient lists and its caps; a held send is stored as awaiting_approval, emits approval.requested, and is approved or rejected by a person holding the send:approve scope, which emits approval.decided. The ladder, per inbox autonomous Sends are queued immediately, subject to sponsor gating. Shipped send_when_confident Each send is checked by outbound safety questions and goes o… Shipped send_with_approval Every send is held until a human approves or rejects it. Shipped send_to_allowlist Sends to allowlisted recipients go out; any other recipient … Shipped draft_only Sending is refused; the agent writes drafts that a person se… Shipped read_only Sending is refused. Shipped A send from any surface send · reply · forward REST, MCP, JMAP or SMTP Server checks the tier lists, caps, sponsor gating Queued and sent message.sent Held: awaiting_approval approval.requested A person decides queue, Slack or email link agents cannot approve approval.decided approved: sent as held rejected: never sent Refused read_only, draft_only, blocked
Each inbox sits on one rung. Every surface that sends (REST, SDK, MCP, JMAP, SMTP submission) goes through the same check of tier, lists and caps, and a held send waits for a person whose key has the send:approve scope, in the approval queue, Slack or a signed email link.
TierWhat it doesStatus
read_onlySending is refused.Shipped
draft_onlySending is refused; the agent writes drafts that a person sends.Shipped
send_to_allowlistSends to allowlisted recipients go out; any other recipient is held for approval or refused, as the inbox's policy says.Shipped
send_with_approvalEvery send is held until a human approves or rejects it.Shipped
send_when_confidentEach 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
autonomousSends 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.

Approve a held send
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.

Allow a domain, then check
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.

A cautious outbound agent
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.

File one vendor's PDFs for payment
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.

Everything held this week, and every send action
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.

CapabilityWhat it doesStatus
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