Skip to content
nofeb

Email agents for operations teams

For freight brokers, logistics software, and real-estate, mortgage and title operations

Operations work is a set of threads, each a case with a stage, a counterparty and a deadline. nofeb keeps that state on the thread as typed metadata, wakes the agent with thread.due when a deadline passes without a reply, answers queries such as every quote still unanswered after four hours, and lets a person take any case over, so the agent chases and a human handles the exceptions.

Checked against the engine on .

What gets in the way?

  • A quote request fans out to a dozen carriers, and the replies come back in any order and format.
  • Closings stall on one missing document, and nobody notices until the deadline.
  • Follow-up rules live in spreadsheets and cron jobs that drift from the mail.

How does nofeb handle it?

A thread per case

Lane, offered rate, deadline and owner, or checklist and documents received, as typed metadata on the thread. Attachments arrive with extracted text and are filed byte-exact.

Deadlines that wake the agent

follow_up_at on each thread; thread.due fires with the thread's metadata when it passes, and the agent chases or escalates.

The whole board in one query

query_threads looks across every desk's inbox and pod by metadata values and ranges and by the direction and age of the last message, so a supervisor agent can list every stalled case without opening a single thread.

Signings on the calendar

Each inbox has a calendar: find a slot that suits every inbox involved, book it, and the invitations go out by email; replies and cancellations update the event.

People on the exceptions

A coordinator opens the case in the webmail, takes the thread over, and the agent's sends on it stop until it is handed back; the metadata panel shows the case's state beside the mail.

A thread as a state machine with a follow-up timer Stages new, quote_sent, negotiating, won are stored as the thread's stage metadata. An agent writing follow_up_at arms a timer; when the time passes, a thread.due event carrying the thread's metadata is delivered by webhook and the event feed, and the agent takes the next step. Moving follow_up_at moves the timer and clearing it cancels it. stage, stored on the thread new reply quote_sent reply negotiating reply won Thread metadata stage: "quote_sent" owner_agent: "freight-desk" follow_up_at: "2026-10-03T09:00Z" Timer armed by nofeb moves when follow_up_at moves cancelled when it is cleared no scheduler of your own thread.due by signed webhook or the event feed with thread_id, inbox_id, due_at and the thread's metadata Agent takes the next step chase, escalate or close writes the new stage and the next follow_up_at
The thread carries its own state. A reply or an agent moves the stage; setting follow_up_at arms a timer, and if nothing changes before it passes, thread.due wakes the agent with the thread's metadata attached.

What does the code look like?

Fan out a quote request and arm follow-ups (TypeScript)
for (const carrier of carriers) {
  await nf.messages.send(desk.id, {
    to: [carrier.email], subject: `Quote: ${lane}`, text: request,
    thread_metadata: { stage: "quote_requested", carrier: carrier.id, follow_up_at: hoursFromNow(4) },
  });
}
// thread.due arrives for every carrier that has not answered in four hours.
Every quote still waiting on the carrier (REST)
curl -X POST https://api.nofeb.com/v1/threads/query -H "authorization: Bearer $NOFEB_API_KEY" \
  -H 'content-type: application/json' \
  -d '{"metadata": [{"key": "stage", "op": "=", "value": "quote_requested"}],
       "last_message_direction": "outbound", "last_message_before": "now-4h"}'

Where does nofeb stop?

  • nofeb is not a TMS, e-signature or transaction-management system; it carries the conversations and their state.

Frequently asked questions

How do I follow up automatically when a carrier does not reply?

Set follow_up_at on the thread when you send; clear it when a reply arrives. thread.due fires for the threads that are still waiting.

Can a manager see every stalled case at once?

Yes: POST /v1/threads/query with the stage and last_message_direction and last_message_before filters returns them across inboxes and pods, with each thread's metadata.

Can different clients' mail be kept apart?

Yes: a pod per client, with keys and webhooks scoped to the pod.

Status of everything on this page

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

CapabilityWhat it doesStatus
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
Follow-up timers Set follow_up_at on a thread and, when that time passes, a thread.due event carrying the thread's metadata goes to your webhooks and the event feed, so agents need no scheduler of their own. Shipped
Queries across threads by metadata Find threads across inboxes and pods by typed metadata values and ranges, by decision probabilities, and by the direction and age of their last message (every thread at stage quote with no reply for four hours), plus an inbox directory searchable by metadata. Shipped
Unlimited inboxes Create as many inboxes as the work needs, with a generated or chosen address and an idempotent client reference. Shipped
Pods Sub-tenants inside one organization: one per end customer, created idempotently from your own customer id. Shipped
Attachment text Attachments are listed with their extracted text and can be downloaded byte-exact. Shipped
Folders, keywords and labels Folder roles with unread counts, plus keywords such as seen, flagged or your own labels. Shipped
Calendar per inbox A calendar on every inbox: events with recurrence and time zones, invitations, updates, cancellations and replies by email, auto-accept rules, free/busy, availability and booking that sends the invitations, MCP tools for scheduling, and CalDAV and JMAP Calendars for standard clients. Invitations an agent sends follow its inbox's autonomy tier. 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
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
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