---
title: Get client feedback on an AI-generated report, without retyping
description: Readers comment directly on the published report — no account needed. You review the feedback and point your agent at what's worth fixing. No re-typing.
date: 2026-08-27
order: 3
query: get client feedback on an AI-generated report
---

# Comments that come back to your agent

The reliable way to get client feedback on an AI-generated report is to collect it on the report itself, not in your inbox. Publish the report to a stable URL, let the client comment directly on the passage they mean — no account required — and once you have read the comments and decided which ones deserve action, point your agent at exactly those. The agent pulls the threads, makes the changes you directed, republishes to the same URL, and replies to each commenter describing what changed. Nobody re-types feedback into a prompt, and nothing in the report changes unless you decide it should.

That is the loop Send Artifact is built around. This guide covers why the feedback leg is the hard half of sharing AI-made work, how the loop works in practice, and why — as far as we can tell — nobody else has built it.

## Why is the feedback the hard part?

Sending the report was never the problem. Static hosting is free everywhere, and if a URL is all you need, you have a dozen good options — some listed near the end of this page. The pain starts after the link goes out, because an AI-generated deliverable is almost never a one-shot document. It gets revised, usually several times, usually because someone on the receiving end had opinions.

Watch what those opinions travel through today. The client emails: "the Q3 number looks off, and can the summary be shorter?" Or it arrives as a Slack message, or a screenshot with a red arrow on it. You read it, open your agent, and paraphrase: "the client says a Q3 number is wrong — I think they mean the revenue table — and the summary should be tighter." Then you export a new file, attach it to a reply, and hope everyone opens the right version.

Every hop through that chain loses something. *Which* Q3 number? The paraphrase reaching the agent is yours, not the client's — the exact words, the exact location, and half the nuance are gone. Feedback that arrives across three channels gets consolidated by memory, and the item that came in on Thursday night quietly falls out. You have become the transport layer between your reviewers and your agent, and transport layers made of humans drop packets.

The cost is not just the re-typing. It is that each round trip is annoying enough that you do fewer of them. Reports ship at draft two instead of draft four, not because draft two was good enough but because the loop was too heavy to run again.

## How do readers leave feedback without creating an account?

With Send Artifact, the report lives at a stable URL — `sendartifact.com/you/q3-report` — and readers comment directly on it. A reader selects the passage they mean and chooses **Comment**, or chooses **Drop a pin** to comment on a spot. Viewers never need an account: on an open link they just read and comment, and on gated artifacts they verify an email with a one-time code, which is not an account either.

Two properties make these comments worth more than an email saying "the numbers seem off":

- **They are anchored.** Each comment stores the quoted passage and its surrounding context, so it stays attached to the thing it is about across revisions. If a later version removes that passage entirely, the thread is flagged as orphaned rather than silently lost — you still see the feedback and judge whether it still applies.
- **They are attributed where possible.** On artifacts shared with specific guests, or open artifacts that ask for the reader's email before viewing, you see who said what.

Access control is yours to set: artifacts start private, and you can widen to specific guests (individual emails or a whole company domain), anyone with the link, or fully public. Open modes can optionally ask readers for their email — self-reported, or verified with a code — before the page renders. And comments are on by default but can be switched off per artifact, for audiences that are meant to read rather than review.

The demand for this is not hypothetical. A seven-person dev shop recently built anchored, anonymous reader comments into their own internal artifact-hosting tool after a client refused to join their internal tooling just to read their work — and once they had it, "People we shared with kept asking how they could do the same" ([nathanjryc, Show HN](https://news.ycombinator.com/item?id=48722493)). Reviewers want to mark up the actual page. They have wanted it for as long as documents have been sent.

## What happens when you point your agent at the comments?

The comments sit on the artifact until you deal with them. You read them the same way your client left them — in place, attached to the passage they are about. Then the loop runs like this:

1. **You triage.** Some comments are right, some are wrong, some are out of scope, and some are questions rather than change requests. That judgment is yours; no tool should be making it.
2. **You direct your agent.** Something like: *"Pull the comments on q3-report. Fix the revenue figure Priya flagged and tighten the executive summary as she asked. Leave the question about methodology open — I'll answer that one myself."*
3. **The agent reads the exact feedback.** `npx @sendartifact/cli comments` returns each open thread: who wrote it, the quoted passage, and the surrounding context that locates it in the page. Your client's words reach the model verbatim — no paraphrase in the middle.
4. **The agent edits and republishes — same URL.** It pulls the live HTML, makes the changes you directed, and republishes under the same slug. Republishing creates an immutable new version at the link everyone already has; every previous version is retained, with rollback if a revision goes wrong.
5. **The agent resolves what you told it to resolve.** For each comment you directed it to address, `npx @sendartifact/cli resolve` closes the thread with a concrete reply naming what changed — and that reply is shown to the commenter. Feedback you chose to decline or answer with a question gets a reply that leaves the thread open.

Your client's next visit needs nothing from them: the link they already have now serves the updated report, and the comment they left carries a reply explaining exactly what was done about it. Analytics on the same artifact — views by day and by version, distinct readers, active read time, scroll depth, with bot and link-preview hits filtered out — tell you whether they actually came back and read the revision.

![The feedback loop: you publish to a stable URL, readers comment on the artifact, you review and choose what to address, you direct your agent, and the agent republishes to the same URL](/guides/assets/comments-that-reach-your-agent-diagram.svg)

## Does anything change without your sign-off?

No, and this is worth being precise about. A reader comment is a message to you, not an instruction to your agent. The agent reads comments only when you run it and tell it to, changes only what you direct, and resolves only the threads you named. A client who leaves a comment at midnight has not triggered anything; they have left a note that will be exactly where they put it when you decide what to do with it.

That is a design position, not a limitation. Your reviewers do not have final say over your deliverable — you do. The point of the loop is not automation for its own sake; it is that when you *do* decide to act, the feedback is already in a form your agent can consume, so acting costs one sentence of direction instead of an evening of re-typing and re-sending.

## Why doesn't the rest of the market do this?

We went looking, and the answer surprised us: the return leg of the loop has essentially no coverage anywhere. The tools that share AI-generated pages treat the sent link as the finish line.

The AI vendors' own sharing stops at the boundary of your organization. Claude Code Artifacts supports comments internally, but Anthropic's docs are explicit that "Comments aren't available while this Artifact is shared publicly" ([Claude Code docs](https://code.claude.com/docs/en/artifacts)) — the external reader, the person whose feedback you most need, cannot comment at all. And the dedicated hosting tools that do collect viewer feedback treat it as something the author exports and ferries back to the model by hand. Feedback you re-type is feedback that gets lost.

| Tool | Outside readers can comment? | How feedback reaches your agent |
| --- | --- | --- |
| Claude Code Artifacts | Not on public shares ([docs](https://code.claude.com/docs/en/artifacts)) | It doesn't |
| Dedicated sharing tools | Sometimes, as exportable feedback | You copy it over by hand |
| Send Artifact | Yes — anchored, no account needed | You point your agent at `npx @sendartifact/cli comments` |

The gap makes a kind of sense. If you think of publishing as hosting, the job ends when the page is up. It only looks unfinished once you notice that the author is standing in the middle of every revision, hand-carrying feedback from readers to a model that could have read it directly — with the author's permission.

## What if you only need to host the file?

Then you should use whatever is closest to hand, honestly. GitHub Pages, Netlify Drop, Cloudflare Pages, an S3 bucket — all of them will serve a static HTML report for free, and if the report will never be revised and you don't care who reads it, any of them is a fine answer.

Send Artifact earns its place after the link is sent: the URL stays stable across every revision, access is controlled without making viewers create accounts, you can see whether the report was actually read, and the feedback arrives anchored to the page in a form your agent can act on — when, and only when, you direct it to.

## How do you start?

Publishing is agent-native. Your coding agent can use the CLI (`npx @sendartifact/cli`) or the skill file at [sendartifact.com/skill.md](https://sendartifact.com/skill.md), which teaches it those same commands; there is also a web drop-zone if you would rather drag a folder in. Artifacts are self-contained static files, up to 25 MB. Everything publishes private by default — widen access when you are ready for readers.

From there the loop is short: publish, send the link, read what comes back, and point your agent at the comments you want addressed. The re-typing disappears. The judgment stays with you.

Questions: [support@sendartifact.com](mailto:support@sendartifact.com).