Connect an AI agent

Feedback ships a remote Model Context Protocol server, so Claude — or any MCP client — can work with your site directly: summarize and triage what your users are saying, send a client a batch of questions, and read back what they answered. No polling code, no glue; the agent gets tools.

Connect

Grab a token from your site's Setup → Connect an AI agent section (it's shown once), then add the server. With Claude Code:

claude mcp add --transport http latentedge-feedback \
  https://feedback.latentedge.io/api/v1/mcp \
  --header "Authorization: Bearer sk_your_secret_token"

Or in any MCP client that supports remote HTTP servers with a bearer header:

{
  "mcpServers": {
    "latentedge-feedback": {
      "type": "http",
      "url": "https://feedback.latentedge.io/api/v1/mcp",
      "headers": { "Authorization": "Bearer sk_your_secret_token" }
    }
  }
}

Your site's Setup tab has a one-click copy of this config with your token already filled in.

Read token or write token

Two per-site secrets, generated separately, so you choose how much the agent can do:

`sk_…`	Read. The agent can browse, search, and summarize feedback, and read question batches and their answers — but change nothing.
`wk_…`	Read + write. Everything above, plus triaging feedback and creating question batches. A leaked read token still cannot modify anything.

Both are secrets — keep them out of client-side code — and both are scoped to exactly one site and rotatable from the dashboard. The connection only advertises the tools its token can actually call, and every call is checked server-side regardless.

Tools

`list_feedback`	List submissions newest-first, filterable by `type`/`status`, with cursor pagination.
`search_feedback`	Full-text substring search over messages — "what are people saying about X".
`get_feedback_stats`	Totals, last-7-days count, breakdowns by type and status, and average rating.
`list_question_batches`	The site's question batches with status and question/answer counts. Share links never included.
`get_question_batch`	One batch's questions beside the client's answers.
`update_feedback_status`	Set an item's status to `new`, `triaged`, or `resolved`. Write token only.
`create_question_batch`	Draft a new batch for you to review and send from the dashboard - an agent cannot put questions in front of your client on its own. Pass `sendNow: true` to publish it there and then and get the share URL back. Write token only.

Things to ask it

Once connected, the agent picks the right tools on its own:

"Summarize this week's feedback and flag anything urgent."
"Triage everything new: mark bugs you can reproduce as triaged."
"Send the client a batch asking the three open design questions."
"Did they answer the launch questions yet? What did they say?"

Give your agent the skill

New

The tools tell an agent what it can call; a skill tells it how to work them well — triage without bulk-resolving, get batch questions approved before publishing, treat the share URL as the secret it is. We maintain one skill file covering both channels. If your agent supports skills (Claude Code does), install it and you're done:

mkdir -p ~/.claude/skills/latentedge-feedback && \
  curl -fsSL https://feedback.latentedge.io/skills/latentedge-feedback/SKILL.md \
  -o ~/.claude/skills/latentedge-feedback/SKILL.md

Or copy the whole file — it's plain Markdown, so it also works pasted into any agent's instructions. Hosted at /skills/latentedge-feedback/SKILL.md:

---
name: latentedge-feedback
description: Work a site's user feedback and client question batches through the feedback.latentedge.io MCP server. Use when asked to check, summarize, search, or triage feedback, or to send a client/stakeholder a batch of questions and read back their answers.
---

# Feedback

You are connected (or will connect) to one site's feedback on feedback.latentedge.io.
The site has two input channels, and this skill covers both:

- **Widget feedback** - passive, continuous: visitors submit feedback, feature requests, and bug reports through an embedded widget.
- **Question batches** - active, on-demand: the owner sends a named person a set of questions via a share link; they answer in the browser with no account.

## Connect (once)

If the `latentedge-feedback` MCP server is not connected yet, ask the user for their site token
(dashboard: Setup -> Connect an AI agent; `sk_` = read-only, `wk_` = read + write), then:

```bash
claude mcp add --transport http latentedge-feedback \
  https://feedback.latentedge.io/api/v1/mcp \
  --header "Authorization: Bearer THEIR_TOKEN"
```

The token scopes you to exactly one site. On an `sk_` connection the write tools are
absent from `tools/list` - that is intentional, not an error; tell the user a `wk_`
token enables them.

## Tools

| Tool | Scope | Use |
|---|---|---|
| `get_feedback_stats` | read | Overview first: totals, last-7-days, type/status breakdowns, average rating. |
| `list_feedback` | read | Browse newest-first; filter by `type` (feedback/feature_request/bug) and `status` (new/triaged/resolved); paginate with `cursor`. |
| `search_feedback` | read | Keyword search in messages - "what are people saying about pricing". |
| `list_question_batches` | read | Batches with status (draft -> sent -> opened -> answered) and answer counts. |
| `get_question_batch` | read | One batch: questions beside the client's answers. |
| `update_feedback_status` | write | Mark an item `triaged` (reviewed) or `resolved` (addressed). |
| `create_question_batch` | write | Draft a batch for the owner to review and send. `sendNow: true` publishes it and returns the share URL. |
| `get_question_batch_link` | write | The share URL of a batch you already sent, when you no longer have it to hand. |

## Working feedback

- **Summarize**: `get_feedback_stats` first, then `list_feedback` for the detail. Lead
  with what changed recently and anything urgent (bugs with high ratings of pain,
  repeated themes). Quote messages sparingly and verbatim.
- **Triage**: work through `status=new` items. Mark an item `triaged` only after you
  have actually read it and told the user about it; mark `resolved` only when the user
  says it is addressed. Never bulk-resolve to tidy up.
- **Investigate a theme**: `search_feedback` with 2-3 phrasings (users misspell and
  paraphrase), then read the hits before concluding.

## Working question batches

- **Draft questions**: build the batch from what the user wants to ask - one clear
  question per item, numbered, optional HTML context under each. `create_question_batch`
  creates a DRAFT: nobody can reach it, and the owner reviews, edits and sends it from
  the dashboard. Report the batch id and say it is ready to review. Do not describe a
  link - there is not one yet, and a sent batch cannot be edited, so the review is what
  makes editing possible at all.
- **Send only when asked.** `sendNow: true` publishes immediately and returns the share
  URL. Use it when the user has actually said to send, not as a shortcut. Once sent, the
  questions are final.
- **Hand over the share URL immediately** when you do send. The user cannot pass the
  batch on without it, so give it prominently rather than burying it in a summary. It is
  also the batch's entire access control: anyone with the link can answer, so it goes to
  the intended recipient only, and it does not belong in a group thread or a ticket.
- **If you no longer have the URL**, `get_question_batch_link` returns it - find the
  batch with `list_question_batches` first. It only works on a sent batch; a draft has no
  live link. Nothing is lost by not hoarding it.
- **Read answers**: `list_question_batches` to find the batch (status `answered` means
  they submitted; `opened` means they are looking; `draft` means the owner composed it
  in the dashboard and has not sent it, so there is nothing to read yet), then
  `get_question_batch` for the answers. Present each question with its answer; unanswered questions are worth
  pointing out, not hiding.
- Answers can be revised until the owner reviews them - if the user acts on an answer,
  note when it was last updated (`answerUpdatedAt`).

## Boundaries

- Notification emails go to the site owner automatically on submit; you never send mail.
- Do not paste secret tokens (`sk_`/`wk_`) into files, logs, or messages.
- Rate limit is 60 requests/minute for the site - batch your reads; never poll in a loop.
- If a write tool errors with "read-only", report it and suggest a `wk_` token; do not
  retry or work around it.

---

Maintained by [LatentEdge](https://latentedge.io) - part of [Feedback](https://feedback.latentedge.io).
Canonical copy: https://feedback.latentedge.io/skills/latentedge-feedback/SKILL.md
Re-download that URL to pick up new tools and guidance as the product grows.

Good to know

Transport is stateless Streamable HTTP — a plain POST per message, no session to manage.
Rate limit is 60 requests per minute per site, shared with the REST API.
Question-batch share links appear only when a batch is created — never in lists — so a connected agent cannot leak an existing client's link.

Building a pipeline instead of connecting an agent? The same tokens drive the REST data API. Embedding the widget? See the install guide. Questions? Get in touch.