Skip to content
nofeb

Email infrastructure for AI support agents

For support and operations leads, and the engineers putting an agent on support@

Give the agent a nofeb support inbox. Hostile mail is scored and quarantined before the agent reads it; every other message arrives with decisions on urgency, intent and whether a person is needed, and rules route it. The agent searches past tickets, writes drafts or held replies that a person approves from the webmail or Slack, and any person can take a ticket over and hand it back.

Checked against the engine on .

What gets in the way?

  • Support mail is the most public inbox a company has, and some of it is written to manipulate the agent reading it.
  • A wrong reply sent to a customer is a ticket, a refund or a headline.
  • The case's state ends up in a separate database the agent has to keep in sync with the mail.
  • When a person steps in, the agent keeps answering the same customer in parallel.

How does nofeb handle it?

Hostile mail held back

Each message is scored for prompt injection on arrival; above the threshold it is quarantined for a person to release or delete. What the agent reads comes through safe_body, stripped of hidden text and marked as data.

Triage before the agent

Urgency, intent, needs-reply and requires-human arrive as typed decisions on every message, and rules act on them: label it, move it, forward it to another team's inbox, or quarantine it.

Answers from past tickets

The agent searches every support inbox by meaning and by words, filtered by customer domain, date or ticket metadata, before it writes.

Replies a person approves

At draft_only the agent writes drafts a person edits and sends; at send_with_approval each reply is held. People decide in the webmail's approval queue or from Slack.

Taking a ticket over

A person takes the thread; until they hand it back the agent's sends on it are held or refused, and thread.driver_changed tells your systems who is driving.

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.

What does the code look like?

Subscribe one inbox and verify deliveries (TypeScript)
await nf.webhooks.create({
  url: "https://example.com/nofeb/events",
  scope: "inbox", inbox_id: inbox.id,
  events: ["message.received", "thread.due", "approval.requested"],
});

import { verifyWebhook } from "@nofeb/sdk";
const event = await verifyWebhook(rawBody, headers, process.env.NOFEB_WEBHOOK_SECRET!);
Find earlier tickets like this one (REST)
curl -X POST https://api.nofeb.com/v1/search -H "authorization: Bearer $NOFEB_API_KEY" \
  -H 'content-type: application/json' \
  -d '{"query": "refund for a duplicate charge", "target": "threads",
       "filters": {"after": "now-90d", "mailbox": "inbox"}}'
A held send, approved by a person (TypeScript)
// The agent's inbox runs at send_with_approval.
const sent = await nf.messages.send(inbox.id, { to: ["dana@example.com"], subject: "Quote", text });
sent.status; // "awaiting_approval"; approval.requested goes to your webhooks

// Later, from a tool a person uses, with a key that holds send:approve:
await approver.sends.decide(sent.send_id, { approve: true }); // approval.decided; sent exactly as held

Where does nofeb stop?

  • nofeb is not a help desk: it has no customer portal, macros or reporting. Pair it with the help desk you use, or build on the API.

Frequently asked questions

How do I build an AI support agent with its own inbox?

Create a support inbox, subscribe a webhook to message.received, give the model safe_body and get_thread_context, and reply with reply_to_message. Start at send_with_approval.

How do I keep replies in the same thread?

Use reply_to_message: nofeb sets In-Reply-To and References from the original, and replies default to the original sender.

Can a support lead approve replies from Slack?

Yes. Add a Slack approver with your app's incoming webhook and signing secret; held replies arrive with Approve and Reject buttons, optionally limited to named Slack users, and the message updates in place once decided.

How do I stop the agent sending something wrong?

send_with_approval holds every send for a person; agent keys never hold the send:approve scope.

Status of everything on this page

Every capability named above, with its status as reconciled against the engine.

CapabilityWhat it doesStatus
safe_body for untrusted mail The message's new text with zero-width and direction-altering characters, hidden HTML and forgeable quoted history removed, wrapped in a provenance header that tells the model whose words these are. Shipped
Injection scoring and quarantine Every inbound message gets a prompt-injection score from 0 to 1 with its reasons: hidden text, invisible and look-alike characters, instructions aimed at an AI, role and chat-template tokens, tracking beacons, data-carrying links and encoded payloads. Above the threshold you set per organization, pod or inbox, the message is quarantined (or only flagged) for a person to release or delete, and its content stays out of the delivery event. 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
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
Search that understands Full-text and semantic search over subjects, addresses, the new text of each message, attachment names and attachment text, across every inbox a key can see. Filter by inbox, pod, folder, thread, sender, recipient, date, attachments, keywords, authentication failures and metadata; results carry highlighted snippets and can be grouped by thread. Shipped
Drafts Agents write drafts that a person edits and sends, over the API, MCP, JMAP, IMAP and the webmail. It is the documented path for draft-only inboxes: sending a draft needs the approval permission agents do not hold. 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
Webmail for the humans in the loop A full webmail and calendar on the same mailboxes the agents use, with an agent-activity timeline, the approval queue, a per-thread driver lock and a metadata panel, signed in through the same accounts as the console. It opens with hosted access. 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
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
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
Typed metadata on messages, threads and inboxes Merge-patch keys onto a message, a thread or an inbox, and declare a key's type so every write to it is validated. Shipped
LLM-ready thread context A whole thread, oldest first, with safe_body text and the thread's metadata, in one call. Shipped
Signed webhooks with required scope Standard Webhooks signatures, retries and a delivery log. Scope (organization, pod or inbox) is required, so a subscription never silently widens to everything. Shipped