Skip to content
nofeb

Approving an agent that touches email

For cTOs, platform leads and security reviewers

nofeb puts the controls where an agent cannot route around them. The sending policy lives on the inbox and is enforced on the server for every interface; approval is a separate scope agent keys never hold; inbound mail is authenticated, scored for injection and quarantined before a model sees it; every change lands in an append-only audit log; agents are registered, can authenticate with their Entra ID, Google, EKS or GitHub Actions identity instead of a stored key, and their mail is signed; people sign in through your identity provider; storage is encrypted per tenant.

Checked against the engine on .

What gets in the way?

  • A prompt is not a permission system: any credential that can send can be made to send.
  • Every stranger with the address can put text in the agent's context.
  • After an incident, nobody can say which agent sent what, or who approved it.
  • Connecting agents to Gmail or Microsoft 365 means broad mailbox scopes, and for Gmail restricted scopes, a security assessment.

How does nofeb handle it?

Blast radius

Keys bound to an organization, pod or inbox, holding only the scopes they are given; a key cannot mint a wider one. Caps per inbox and per key, and recipient blocklists that apply on every tier, bound what a compromised agent can send.

Who did what

The audit log records every change through the API, MCP and the console and every hold, denial and approval with actor, key, operation, target and request id, exportable as JSON Lines. Each agent is registered with a human sponsor, and its mail carries a signature anyone can verify.

No long-lived agent secrets

An agent can present the token its platform already issues (Microsoft Entra ID or Entra Agent ID, a Google service account, an Amazon EKS service-account token, a GitHub Actions OIDC token or any OIDC issuer) and exchange it for a nofeb token that lasts minutes and cannot be refreshed. A binding matches an exact subject plus claim conditions such as repository and branch, caps the scopes, and can confine the agent to one pod or inbox; nothing secret is stored, each external token is accepted once, and deleting the binding or revoking the agent ends its sessions at once.

Injection exposure

Every inbound message gets an injection score with reasons and a sender trust label; above your threshold it is quarantined for a person. safe_body removes the hidden tricks and marks email as data, and tiers bound what a manipulated agent can do.

People and data

Console and webmail sign-in through OIDC or SAML with SCIM deprovisioning; retention policies and legal holds per scope; full export as mbox or EML with metadata. Stored mail and metadata are sealed with keys derived per tenant.

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?

Send decisions in the audit log, newest first (REST)
curl "https://api.nofeb.com/v1/audit?action=send.*&limit=100" -H "authorization: Bearer $NOFEB_AUDIT_KEY"
# A key needs the audit:read scope, which agent keys are not given by default.
curl "https://api.nofeb.com/v1/audit/export" -H "authorization: Bearer $NOFEB_AUDIT_KEY" > audit.jsonl
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
An agent in GitHub Actions exchanges its OIDC token, no stored key (shell)
# The workflow needs permissions: id-token: write
JWT=$(curl -s -H "authorization: Bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \
  "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=api://nofeb" | jq -r .value)
NOFEB_TOKEN=$(curl -s https://api.nofeb.com/oauth/token \
  -d grant_type=urn:ietf:params:oauth:grant-type:token-exchange \
  -d subject_token_type=urn:ietf:params:oauth:token-type:jwt \
  --data-urlencode "subject_token=$JWT" | jq -r .access_token)

Where does nofeb stop?

  • nofeb trusts identities your issuer already mints; it does not issue workload identities itself, accept delegated actor tokens, or hand federated sessions a refresh token, and each agent is still registered in nofeb with a sponsor.

Frequently asked questions

What stops a hostile email from steering the agent?

Nothing removes the risk entirely. nofeb scores each message for injection and quarantines it above your threshold, strips hidden text and forged quotes, marks email as data, and bounds the damage: an inbox at send_with_approval cannot send anything a person has not approved.

How do I limit what an email agent can send?

Choose the inbox's autonomy tier, scope the agent's key to that inbox, set caps and recipient lists, and keep send:approve for people.

Can we require SSO for everyone?

Yes, on plans that include SSO. Verify your domain, connect your identity provider, and turn on enforcement; magic links stop for your domains and every session for the organization must come through your connection, including the sign-in behind the webmail and MCP clients.

Does reading Gmail from my agent require a CASA assessment?

Agents working in their own nofeb inboxes need no Gmail scopes at all. Google's requirements for apps that use restricted Gmail scopes are summarised, with sources, on the Gmail and Microsoft Graph page.

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
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
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
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
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
Agent identity and signed mail Register each agent with a name, a human sponsor and the keys it acts through. Its mail carries an agent header and a signature over the sender, recipients, subject and body that anyone can check against your organization's published keys or nofeb's verification call. Revoking an agent stops its keys from sending and marks its mail as revoked. 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
Sender trust on every message Each inbound message is labelled trusted, known, unknown or suspicious, with the reasons: its authentication results, your sender lists, look-alike domains, display-name spoofing, and whether the inbox has corresponded with the sender before. Shipped
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
SSO and SCIM Single sign-on to the console and the webmail with OIDC (Google Workspace, Microsoft Entra ID, Okta or any issuer) or SAML 2.0, verified domains that route sign-in to your identity provider, optional just-in-time accounts and an enforce switch, and SCIM 2.0 provisioning with group-to-role mapping. Deprovisioning ends the person's sessions and disconnects their apps. Included on plans whose row says SSO. Shipped
Retention policies and legal holds Delete messages older than a number of days, or move them to Trash or Archive, per organization, pod, inbox or folder, keeping flagged mail by default, with a dry run that shows what a policy would do. A legal hold blocks every deletion in its scope, including expiry and inbox deletion. Shipped
Full export A whole inbox, a folder, a thread or a search as mbox or a zip of EML files, with every message's folders, keywords, metadata and decisions as JSON, built in the background and downloaded through signed links. Shipped
Per-tenant encryption with crypto-shredding Stored mail and metadata are sealed with keys derived per tenant; deleting a tenant's key material makes its data unreadable. Shipped
Agent identity federation (no stored API key) An agent signs in with the identity its cloud or CI platform already gives it: Microsoft Entra ID or Entra Agent ID (v2.0 tokens), Google service accounts, Amazon EKS service-account tokens (IRSA), GitHub Actions OIDC tokens, or any OIDC issuer. Your organization trusts the issuer and binds an exact subject, plus optional claim conditions such as the repository and branch, to a registered agent with a scope ceiling and an optional pod or inbox restriction. The agent exchanges its token (OAuth 2.0 token exchange, RFC 8693) for a short-lived nofeb access token with no refresh token, usable on the API, MCP, JMAP and the realtime stream. No secret is stored: keys come from the issuer's published signing keys, and each external token is accepted once. Deleting the binding or issuer, or revoking the agent, ends its sessions at once; every exchange is audited, a dry run explains why a token would or would not be accepted, and mail the agent sends carries the external identity in its signed agent claims. Shipped