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, write token, or owner token

Two per-site secrets, generated separately, so you choose how much the agent can do — plus one account-wide token for sweeping every site at once:

`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.
`ok_…`	Portfolio, read-only. One token for the whole account. The agent gets exactly one tool, `list_portfolio_feedback`, which reads feedback across every site you own. No per-site tool is reachable over it — not even the reads — so it can never triage or write; pair it with a site's `wk_` on a second connection for that.

All three are secrets — keep them out of client-side code. Site tokens are scoped to exactly one site and rotatable from the dashboard under a site's Setup tab; the owner token is generated and rotated in the dashboard under Settings → Data API, which also hands you a ready-to-paste client config (see the data API). 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.
`list_portfolio_feedback`	Every site on the account in one sweep: rows in stable order, each naming its site (`siteId`, `siteSlug`, `siteName`), plus the full site list. Same `type`/`status` filters and cursor paging as `list_feedback`; same rows as the REST portfolio endpoint. Owner token only.
`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?"
"Sweep every site on my account and tell me which one needs attention first."

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, or sweep every site on an account with an owner token. Use when asked to check, summarize, search, or triage feedback, to send a client/stakeholder a batch of questions and read back their answers, or to review feedback across a whole portfolio.
---

# Feedback

You are connected (or will connect) to feedback on feedback.latentedge.io - one site with
a site token, or every site on an account with an owner token (see "Sweeping a portfolio").
A 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"
```

A site 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.

An `ok_` owner token connects the same way and exposes only `list_portfolio_feedback`.
The user generates or rotates it in the dashboard under **Settings -> Data API**, which
shows the token once and gives them a ready-to-paste client config and `claude mcp add`
line for it. Connect it under its own server name so it does not collide with a per-site
connection:

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

## 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. |
| `list_portfolio_feedback` | owner (`ok_`) | Every site on the account in one sweep: each row names its site (`siteId`, `siteSlug`, `siteName`), plus the full site list. Same `type`/`status` filters and `cursor` paging as `list_feedback`. |
| `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.

## Sweeping a portfolio

- An `ok_` owner token is read-only across every site the account holds. Connect it as
  its own MCP server (for example `latentedge-feedback-portfolio`) and call
  `list_portfolio_feedback`, paging with `cursor` until `hasMore` is false. Group the
  rows by `siteSlug` when you report, and mention sites that returned nothing - the
  `sites` list includes them, and silence is itself a finding.
- No per-site tool works over `ok_`, reads included, and its cursor is not the
  `list_feedback` cursor. To triage what the sweep found, use that site's `wk_`
  connection; do not try to work around the refusal.

## 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_`/`ok_`) into files, logs, or messages.
- Rate limit is 60 requests/minute for the site - batch your reads; never poll in a loop.
  A portfolio call spends every site's budget at once, so page with a generous `limit`.
- 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. An owner-token connection spends every site's budget on each call, so a portfolio sweep costs what the per-site connections it replaces would.
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.