Intake widgets are commodity. The differentiator is the autonomous back half: a report goes in, an agent reproduces it, opens a pull request, the reporter verifies, and a regression test is minted. No competitor closes that loop end to end.
Marker.io, Usersnap, BugHerd, Userback, Jam, and Canny all capture feedback. That category is commodity. Flagin's differentiator is the autonomous back half, the piece none of them have.
The reporter occupies exactly one position in the loop: they mark what is broken, and they confirm it is fixed. Everything in between is Flagin's job.
Anyone flags an issue via the widget. Route, build SHA, user context, console errors, network failures, and the last 60 seconds of session trace are captured automatically. The reporter only marks, they do not describe reproduction steps.
A triage agent clusters the Finding against open issues by route, build SHA, and trace similarity. Priority is computed from reach, impact, recency, and workaround availability. Fifteen reports collapse to one Finding, all fifteen reporters are tracked.
The agent reproduces the issue, writes the patch, and opens a PR annotated with evidence and reporter count. A webhook moves the Finding to resolved on deploy, not on merge. A reporter asked to verify against an undeployed fix will report it broken again.
The original reporter receives a verify prompt with what changed and a link to the affected screen. They confirm or reopen. On confirmation, Flagin mints a regression test automatically. Human finds it once. The machine finds it every time after.
Four mechanics keep reporters engaged. Every one runs automatically, no engineering effort after initial setup.
accepted, resolved, wont_fix, and deferred. wont_fix always carries a human-written reason.One object, one board, one triage path, regardless of whether a human or a machine noticed the problem. All three producers emit the same Finding with a different origin field.
Deliberate human act. A reporter clicks the persistent Flagin widget, available on every screen. Arrow, box, and text annotation converts vague reports into located ones. Works offline, queues until connectivity returns. Under 40 KB gzipped.
Ambient session telemetry detects anomalies, dead clicks, rage clicks, abandoned flows, and error spikes, creating a Finding before any user reports anything. Of 40 users, perhaps 8 will ever flag anything. The other 32 are visible here.
Flagin's grader runs your test suite after every deploy and scores each failure. Regressions surface as Findings with full diff context, failing assertion output, and environment metadata. Graded Findings land on the Signals board until the grader's false-positive rate is calibrated.
The naming is normative. Code, schema, UI copy, and documentation all follow it. The reasoning is worth knowing, it explains what the product is and is not.
| Word | Job | Where it appears |
|---|---|---|
| flag | The user's deliberate act of capture. A verb, not a noun. | Widget button label, "flag this," notification copy |
| Finding | One record, something found, regardless of who or what found it. Absorbs all three origins without strain. | Schema, API, detail page, GitHub cross-link |
| Findings | The collection. Not "Issues," not "Bugs", avoids collision with GitHub Issues, which Flagin writes to. | Left nav label, board title, count badge |
| open | Non-widget creation, pasted reports, promoted Discord messages, filing on behalf of a user. | Internal tooling, promotion actions, API |
| verify | The reporter's confirmation that a fix is real. Only a human can do this. Machines resolve; humans verify. | Notification copy, verification prompt, state label |
| Signals | Observed Findings from ambient telemetry. Separate board until promoted, machine noise does not bury human reports. | Signals board, passive telemetry tab |
Intake is commodity because everyone builds it as a single-codebase feature and rewrites it for the second consumer. Flagin is three deployable pieces from the first commit. Extraction is a decision, not a rewrite.
Script tag, not a React component. window.Flagin.init(). Works in any web app, any framework. Captures route, build SHA, user, environment, console errors, failed network requests, and the last 60 seconds of session trace. Screenshot annotation included.
REST and webhook API for receiving, clustering, and storing Findings. Postgres-backed, own store, not entangled with the knowledge graph, so extraction requires no migration. Tenant-aware from the first commit. Build SHA required at ingest; a Finding without it is unactionable.
Full triage board, embeddable in your product or hosted standalone. Filter by app, type, status, priority, reporter, and build. Threaded comments, evidence viewer, PR link, and the reporter verification flow built in. Consumes the ingest API; your application is the consumer, the data lives in your store.
Every Finding carries route, build SHA, environment, console errors, network failures, session trace, and screenshot. Reproducibility before any code is touched. Reporters do not provide steps, the system does.
On accepted, the agent attempts the fix and opens a GitHub pull request annotated with evidence and affected user count. Engineers never leave GitHub. Reporters never see it. One direction of truth per field, bidirectional comment sync is where integrations die.
Clusters by route, build SHA, console error signature, and semantic similarity. Forty users will report the same broken screen fifteen ways. Without clustering, the board is unusable by week two. Biased toward merging, a bad merge is cheap to undo.
On verification, Flagin generates a test from the session trace and the fix diff and commits it to your test suite. Human QA permanently upgrades machine QA. Human finds it once. The machine finds it every time after.
Keep accepting Google Docs, DMs, and verbal reports. Paste raw text into a Finding and the triage agent structures it, sets type, clusters it, and attributes the reporter. Discord messages, meeting notes, operator observations, all promotable in one action.
Every state transition, comment, evidence attachment, and agent action is logged with a timestamp and actor. wont_fix always carries a human-written reason, an unexplained decline costs more reporter goodwill than the report was worth.
There is no priority field reporters can touch. Reporters always select critical, which destroys the signal. Priority is a function of real, measured data, computed on ingest, updated on new evidence.
Every Finding receives a computed score at triage:
Of 40 beta users, perhaps 8 will ever click the widget. The users quietly abandoning a flow are the strongest signal and will never report anything. A board fed only by manual intake systematically over-represents the loud.
Signals is a passive board fed by ambient session telemetry. Machine noise does not bury human reports, Signals sit separately until promoted with one action. Manual intake reports what people say. Signals report what is actually broken.
A capture widget grabs whatever is on screen. In a client application that means real customer records, contact data, and financial figures. Flagin handles this with DOM-level redaction before any data leaves the browser.
DOM-level masking runs client-side before the capture is sent. A selector allowlist and denylist is configured per tenant. Automated detection for card numbers, government IDs, and email addresses in captured text. Data never leaves the browser unredacted.
Every attachment carries a DATACLASS-001 class before it is stored. Fail-closed: unclassified evidence is not stored. Evidence never crosses tenant boundaries, a tenant engineer viewing a client-app Finding sees redacted evidence unless explicitly granted access.
Evidence retention windows are configurable per tenant, defaulting to 90 days. The Finding record itself outlives its evidence. Reporters can view exactly what was captured before they submit, no silent capture in the flagged path.
Whether you are a solo developer or running quality across a 20-person engineering team, Flagin fits the way you work.
Stop chasing reporters for confirmation. The verify prompt goes out automatically on deploy. Reporters confirm from a single link, no account required.
Findings arrive pre-scored with computed priority, reproduction steps, and evidence attached. You decide what to act on, not what it means.
Signals telemetry and graded Findings surface problems before any user flags them. Regressions against a recent build get a hard priority multiplier.
Embed the widget, connect the ingest API, and get the full lifecycle, capture, triage, fix, verify, without building any infrastructure yourself.
Give clients one place to flag issues. Findings land in your board, evidence-first, ready to triage. Evidence is redacted at the DOM before transmission, client data stays client data.
The @flagin/sdk is a script tag, not a React component. It works in any web application: the same widget, the same API, one board regardless of framework.
Flagin is in active use across multiple applications with real-world defect intake and triage. The early access period is where we close the autonomous resolution loop before opening to the public.
Widget, ingest API, Finding object, filterable board, status notifications, manual triage. This ends the Google Docs era. Acceptance criterion: zero reports arriving by DM or Google Doc for two consecutive weeks.
Clustering agent, computed priority, GitHub issue creation, resolved webhook, verify prompt, weekly digest, and the promotion path for non-widget reports. Done when duplicate rate is under 15% and reporter verification rate on resolved Findings exceeds 60%.
Session trace attachment, evidence redaction and classification, Signals board, screenshot annotation. Redaction is required before Flagin is deployed in any application handling sensitive customer data.
Agent attempts the fix, opens the PR, links it to the Finding, moves to resolved on deploy, mints regression test on verification. Done when at least 25% of accepted Findings reach resolved with no human writing code.
Multi-tenant hardening, standalone hosted board, self-serve onboarding, documentation, pricing. Extraction is a decision here, not a rewrite, because Flagin was built as three separable components from the first commit.
Flagin is free to start. The full autonomous resolution loop is in early access. Request a spot and we will follow up.
Flagin is in limited early access. Drop your details and we will follow up.