---
name: support-inbox
description: Work the LastWorker support inbox. Pull the email, web chat and SMS threads that need a reply, look each customer up in your own systems, and post an accurate reply. Use when asked to "do the inbox", "draft support replies", or when /support-inbox is invoked.
---

# Support inbox

Goal: every thread in the LastWorker inbox that is waiting on a person gets a reply grounded in
your own data, not in the customer's description of the problem.

Replies are posted with `mode: "draft"` unless the account owner has said otherwise. A draft sits
in the LastWorker inbox until a person reads it and presses Send. Nothing reaches a customer
without that step. Only read from your own systems while working this skill. Do not write to them.

## Setup, once

Create an API key at https://lastworker.com/dashboard/mcp and add the server:

```bash
claude mcp add --transport http lastworker https://lastworker.com/api/mcp \
  --header "Authorization: Bearer lw_live_..."
```

Cursor takes the same URL and header in .cursor/mcp.json. Claude Desktop takes them as a custom
connector with No sign-in and a Request headers entry. Every call below is a LastWorker MCP tool. The same data is available over REST at
https://lastworker.com/docs/agents if you prefer curl.

## 1. Get the threads

Call `get_account` first. It lists your agents, each channel's AI mode (auto, review, manual) and
the account's reply setting, which decides whether `post_reply` sends or drafts.

Then pull two lists:

- `list_conversations_needing_reply({ tab: "attention", limit: 100 })`. This is the queue: threads
  whose newest customer-or-agent message is from the customer, with no draft pending, restricted to
  the inbox's Needs Attention tab (escalated, awaiting review, missed). Spam and notification mail
  are already out. Follow `next_before` until it is null.
- `list_conversations({ tab: "all", limit: 100 })`. Every thread in the inbox, including the ones
  the AI already answered. Page back 7 days with `next_before`.

Work every item in the queue whose `needs_reply` is true and `has_pending_draft` is false. Then go
through the 7-day sweep and also open any thread that matches one of these:

- A chat where only the AI answered. The AI's reply clears `needs_reply`, so a customer who keeps
  asking after "the team is looking into it" never reaches the queue. Work any thread where a
  customer message has no human reply after it.
- A thread with a pending draft where the customer wrote again after the draft. Re-check and post a
  new draft, which replaces the old one.

One customer often has a chat and an email thread open at the same time. Search the sweep for the
contact email and read every thread for that customer before writing, so the reply answers their
latest message wherever it arrived.

Each item carries `agent.name`. If you run more than one product through LastWorker, use it to
tell which product the thread belongs to.

If the person gave you one thread id or pasted a conversation, work only that one.

Read the whole thread with `get_conversation({ id })`, not just the last message. Earlier turns
often hold the order number, the amount or the screenshot description that explains the latest one.
Each message lists its `attachments`. Open every one with `get_attachment({ url })` before you
write: customers send the screenshot or the spreadsheet that the question is about.

## 2. Identify the customer

The `contact.email` on the thread is the account email in most cases. Confirm it resolves to one
record in your system before you investigate. If it does not, try the phone number or the name
from the thread. If there is still no match, draft a short reply asking which email the account is
under, and say in the report that the lookup failed.

Fill in how a lookup works for your product:

```
Lookup by email:   <command, SQL, or API call>
Lookup by phone:   <command, SQL, or API call>
What it returns:   <the fields you care about: plan, status, created date, last activity>
```

## 3. Classify and investigate

Pick one bucket, then run that bucket's checks. Write down what you found with dates and amounts.
The reply must rest on evidence.

Fill in your buckets. Three to eight is typical. For each one, name the data source and the exact
query or screen, so the agent does the same checks every time:

```
Billing: "I paid but nothing changed"
  Source:  <billing provider, e.g. Stripe customer search by email, then charges and subscriptions>
  Also:    <your own ledger table or page>
  Known:   <anything that commonly explains this, e.g. a card declined on retry>

Access: cannot log in, verification code never arrives
  Source:  <auth logs, analytics events for the email in the last 7 days>
  Known:   <recent outages or provider changes before blaming the customer>

Feature not working: <name the feature>
  Source:  <the table, log or admin page that shows what the customer actually did>
  Known:   <limits, unsupported cases, common misconfigurations>

Data import or migration
  Source:  <import jobs table, error logs>
  Known:   <what can and cannot be moved, and how long it takes>

Refund request
  Policy:  <your refund policy in one line. The agent repeats it and does not negotiate>

Abuse or fraud signal
  Do not draft a reply. Put the evidence in the report for a person to decide.
```

Add product rules the agent must not get wrong. Examples: a price that is published versus one that
is internal, a limit per plan, a promise support is not allowed to make.

## 4. Write the reply

Sign as a named person on your team. Plain sentences, warm, specific. Say what you checked and what
you found, in the customer's terms (dates, amounts, the thing they clicked). Give the next step they
can take. No bulk apologies, no filler, no "I understand your frustration".

Do not quote internal table names, ids, vendor names or internal counts. Use them to decide what is
true, then state the fact without the number. Do not promise a refund, a date or a change on your
side unless a person has already done it.

Shape:

```
Hi <first name, or nothing>,

<what you found, one short paragraph>

<what happens next or what they can do, one short paragraph>

<name>
<product> Support
```

Plain text. Blank lines between paragraphs. No markdown. No bullet lists unless there are three or
more parallel steps.

If the evidence does not support an answer, write the honest version: what you checked, what you
could not confirm, and one question that would unblock it.

## 5. Post the reply

```
post_reply({ id: "<conversation id>", content: "<reply text>", mode: "draft" })
```

Expect `{ "result": "drafted" }`. Leave `mode` out only if the account owner has told you to send.
The account's reply setting and the channel's AI mode then decide, and the result says `sent` or
`drafted`.

## 6. Report

Finish with one table, one row per thread: customer email, bucket, the evidence in one line, and
whether a draft was posted or why not. Put any thread you were unsure about, and any abuse case, at
the top.
