Public betaEmail first

External communication, managed like infrastructure.

Give Offload a recipient, a goal, and the JSON shape you want back. It runs the thread, follows up, asks for input when blocked, and returns a structured webhook when the case ends.

Read the docs

Typed output

Every case closes with data your backend can use directly.

Escalates cleanly

If a case needs your input, it pauses cleanly and resumes in place.

Built for slow work

Thread handling, waiting, and follow-ups stay off your stack.

Lifecycle preview

One API call, one case owner.

Cases stay in Offload until they finish, fail, or need an answer.

Create case

Objective, counterparty, and result shape.

await offload.createCase({
  goal: "Collect signed W-9",
  counterparty: {
    email: "vendor@acme.com",
  },
  resultSchema: {
    signedW9Url: "string",
    taxId: "string",
  }
});
Automatic Follow-up
acme.com
Acme vendor setup
W-9 request in progress
W-9 collection
Offload
Today · 9:14 AM
Hi Acme team, could you send your completed W-9 so we can finish vendor setup?

Why teams use Offload

External coordination does not belong in your app logic.

The hard part is not sending the first email. It is everything that happens before a trustworthy result exists.

Without Offload

  • External tasks take days, not milliseconds.
  • People do not reply on your schedule.
  • Replies are partial or ambiguous.
  • Models still need human decisions at real moments.
  • Your backend still needs a reliable final result.

Offload handles

  • 01No-reply follow-ups
  • 02Thread ownership
  • 03Long-running state tracking
  • 04Escalation when a case blocks
  • 05Structured final outcomes

It also keeps you from building workers, retry queues, threading logic, and long-running state yourself.

Use cases

Common workflows, without inbox logic.

These are the tasks that usually turn into follow-up jobs, inbox rules, and brittle state machines.

Example request

Collect signed vendor agreements

Keep legal follow-ups and final document capture out of your application code.

await offload.createCase({
  channel: "EMAIL",
  goal: {
    objective: "Collect signed vendor agreement",
    instructions: "Follow up until we receive a signed copy of the MSA"
  },
  counterparty: {
    address: "legal@acme-supply.com",
    name: "Sarah Mitchell"
  },
  resultSchema: {
    signedAgreementUrl: "string",
    signedDate: "string"
  },
  attachments: ["https://files.yourapp.com/msa-draft.pdf"]
});

Case lifecycle

The value is in the middle of the workflow.

Offload owns the waiting, state tracking, and escalation logic until the case reaches a clear end.

  1. 01

    Create case

    Send the goal, the recipient, and the JSON shape you want back.

  2. 02

    Offload runs the thread

    Outreach, waiting, follow-ups, and reply handling stay off your backend.

  3. 03

    The case stays in a known state

    Each case moves toward success, failure, timeout, or a request for input.

  4. 04

    Blocked cases ask for one clear answer

    If a reply needs a decision, you get the missing input and why it matters.

  5. 05

    Resume from the same state

    Reply once through the API and Offload continues without restarting the workflow.

  6. 06

    Receive the final result

    Success or failure arrives as structured data your system can act on immediately.

Final states

Every case ends somewhere explicit.

The point is making the operating state obvious enough for your backend to rely on.

COMPLETED_SUCCESS

The goal was achieved and the result was extracted.

COMPLETED_FAILURE

The goal could not be completed, with the reason preserved.

INPUT_NEEDED

The case is paused and waiting for one specific input.

TIMED_OUT

No response arrived before the deadline.

Structured results you can trust

Define the output shape once. Each case closes with data your backend can use directly.

Human control without inbox work

When a case needs judgment, Offload asks for it explicitly and resumes from the same point.

Pricing

Simple pricing for long-running work.

Creating cases is never charged. Monthly new-case limits keep abuse down, and completions are the billable unit once you move beyond Sandbox.

Sandbox

For setup and testing before live work

  • 100 new cases each month
  • 100 completions each month
  • Shared sending domain
  • Full API access

$0

Pay as you go

For lower-volume production traffic

  • 100 new cases each month (can be raised upon request)
  • Only finished cases are billed

$0.50

per completed case

Base Pro

Recommended

For steady production workloads

  • 500 new cases each month (can be raised upon request)
  • 40 finished cases included
  • 1 custom email domain
  • $0.50 per additional completed case

$20

per month + usage

Need higher volume or custom SLAs? Talk to us about enterprise.

Start in the sandbox

Move the waiting, follow-up logic, and thread state off your stack.

Get started in minutes. No credit card for sandbox access, and production pricing stays tied to completed cases.

99.9% uptime SLANo credit card requiredStructured webhooks
Contact Us