Skip to content

Docs

Documentation

Everything on one page: what Probie does, how to install it, what it captures, how a fix is made, and how agents can use it.

What Probie does

Probie watches real user sessions in your web, Expo, or Swift app and notices the friction people never report: a button clicked five times with nothing happening, a form retried and abandoned, a request that fails quietly. When enough sessions hit the same problem, Probie groups them into one issue with the evidence attached.

For projects connected to a GitHub repository, Probie then reads the codebase, writes the fix with a regression test, and opens a pull request. A person on your team reviews and merges it. After the merge, the behavior baseline for that route flags the friction if it comes back.

Probie also inspects any public website on request. The public form creates a private browser guest identity on first submission; API and MCP callers register email-bound dispatch access first. The inspection runs in a real browser and produces a graded report. Start one at https://probie.dev/dispatch, by HTTP API, or over MCP.

Install

Sign in at /get-started with GitHub, Google, or a magic link, create a project, and copy its widget token from the Integration page. A coding agent can instead register a provisional project after asking its human for an email address and a separate follow-up-consent choice. The token is public by design: it ships to every client that loads the SDK, so it is safe to commit. Projects without a repository are allowed; they get session capture and triage without pull requests.

Web

Add one script tag before the closing body tag on every page you want watched:

<script src="https://probie.dev/assets/probie-widget.js" data-token="YOUR_WIDGET_TOKEN"></script>

This bundle renders a small "Report an issue" button and loads the passive collector. For capture with no visible UI, load the collector on its own:

<script src="https://probie.dev/assets/probie-widget-events.js" data-token="YOUR_WIDGET_TOKEN"></script>

Client-rendered apps (React, Next.js, Vue) inject the same tag once on the client; there is no npm package for the web SDK. After load, attribute sessions to a signed-in user with window.probie('identify', userId).

Expo and React Native

The SDK targets the Expo managed workflow, SDK 50 and later, and has no runtime dependencies.

npx expo install @probie-dev/react-native
import { ProbieProvider } from '@probie-dev/react-native';

export default function RootLayout() {
  return (
    <ProbieProvider config={{ token: 'YOUR_WIDGET_TOKEN', apiBase: 'https://probie.dev' }}>
      {/* your app */}
    </ProbieProvider>
  );
}

The provider captures JavaScript errors, unhandled promise rejections, network failures, and app lifecycle on its own. Screens, taps, and form friction are opt-in hooks documented in the package README on npm.

Swift (macOS and iOS)

The Swift package supports macOS 12 and iOS 15 and later. Instrumentation is explicit; there is no method swizzling.

.package(url: "https://github.com/ProbieAI/probie-swift", from: "0.1.0")
import Probie

Probie.start(.init(token: "YOUR_WIDGET_TOKEN", apiBase: "https://probie.dev"))

Then mark what matters: .probieScreen("Checkout") and .probieTap("buy") on SwiftUI views, Probie.form("signup") for form friction, Probie.captureError(error) in catch blocks, and URLSession(configuration: Probie.instrumented(.default)) for failing requests.

Install with a coding agent

The integration skill at https://probie.dev/skill is a SKILL.md file that walks a coding agent through registration and installation. The agent infers the project name, asks its human for an email and whether limited setup/product follow-up is allowed, provisions a token, installs it, verifies one passive event, and reports the emailed/browser claim flow. Point Claude Code, Cursor, or any agent that reads skills at it, or save it into the repository:

curl -fsSL https://probie.dev/skill -o .claude/skills/probie-integration/SKILL.md

The registration endpoint is POST /api/agent/registrations; it requires email, boolean contact_consent, and a high-entropy Idempotency-Key header. Omit project_name for inspection access, or include it to provision an integration. Every response includes a dispatch token and signed seven-day claim URL; integration responses also include widget and skill credentials. The MCP tools are split by task: register_inspection_access for inspecting only and register_integration for installing Probie.

What the SDKs capture

Every SDK sends the same event types to POST /api/widget/events in small, bounded batches:

pageview, click, rage_click, dead_click, scroll_lock, stuck_overlay, stuck_loading, form_submit, form_retry, form_abandon, js_error, fetch_error, page_leave

The collector is built to see friction without reading content:

Input values
Never read. Form events record that a field was retried or abandoned, not what was typed.
Element labels
Hashed before they leave the page, so a button is recognizable across sessions without its text being stored.
URLs
Query strings are dropped except utm_* campaign tags. Fragments are dropped.
Cookies
None set. Sessions are identified by an id generated in the client.
Sampling
Optional per project through the data-sample attribute.

How the data is stored and for how long is in the privacy policy. Questions go to [email protected].

How a fix is made

When an issue is promoted to a fix, or a ticket is filed from the dashboard or Slack, Probie runs a pipeline of agent roles:

Planner
Reads the evidence and the codebase and writes the plan.
Root-causer or architect
The root-causer traces a bug to its cause; the architect shapes a feature-sized change.
Coder
Makes the change and writes a regression test.
Reviewer
Checks the diff against the acceptance criteria. Failing review sends it back to the coder, up to a configured number of rounds.
Rebaser
Brings the branch up to date with the default branch before the PR is opened.

Each role runs through a configurable agent harness, such as Claude Code, OpenCode, or Pi, in an isolated container. Commits are authored as Probie Bot on a probie/* branch, and the pull request description includes a Tests section that lists the regression tests added.

A person merges. Probie observes the merge or close from GitHub and records the outcome. Probie does not verify individual fixes after merge; what it keeps is a behavior baseline per route, and if the same friction returns on that route the regression is flagged.

Website inspection

Anyone can send Probie to a public website. The browser form grants guest access automatically; agents and scripts register dispatch access with an email and consent choice. Probie opens the website in a real Chromium browser, clicks through the pages a first-time visitor would, and writes a report graded A to D with the evidence for each finding.

  • Public pages by default. With permission, supported sign-in or account-creation flows can give Probie broader access and produce a richer report. Probie reads robots.txt and stays out of what it disallows.
  • Reports are public and listed. Each lives at /report/<id>/<domain-slug> and appears in the gallery and the sitemap.
  • Usage limits apply across the website, API, and MCP. If a limit is reached, Probie tells you when to retry.
  • Bot walls stop the inspection. When that happens, the report says the website was protected and explains how to allow the scanner.

HTTP API

Inspecting only: first register inspection access by omitting project_name. Installing Probie: include project_name in the same registration request. Keep the returned dispatch token secret.

curl -s -X POST https://probie.dev/api/agent/registrations \
  -H 'content-type: application/json' \
  -H 'Idempotency-Key: A_RETAINED_RANDOM_VALUE_AT_LEAST_32_CHARS' \
  -d '{"email":"[email protected]","contact_consent":false}'

Then start an inspection with the dispatch token as a bearer credential. The endpoint allows cross-origin requests.

curl -s -X POST https://probie.dev/api/dispatch \
  -H 'content-type: application/json' \
  -H 'Authorization: Bearer YOUR_DISPATCH_TOKEN' \
  -d '{"url": "example.com"}'
202
{"id": 123, "statusUrl": "...", "pageUrl": "..."}. A new inspection was queued.
200
The same fields plus "reused": true. The website already had a live inspection and you were attached to it.
400
{"error": "..."}. The body was not JSON, had no url, or named a private or reserved address.
401
{"error": "Unauthorized"}. The bearer token was missing, invalid, expired, or revoked.
429
{"error": "...", "retryAfterSecs": n} with a Retry-After header. The hourly limit was reached.

Poll statusUrl (GET /dispatch/{id}/status) every 5 seconds or so. The payload depends on the state:

queued or running
{"status", "progress", "queuedAhead", "activity": [...], "chips": {...}}. activity is a short plain-language log.
ok
{"status": "ok", "reportUrl": "/report/<id>/<slug>"}. The report is ready.
error or skipped
{"status", "failureMessage", "allowUrl"}. skipped means a bot wall stopped Probie; allowUrl explains how to let it through.

MCP server

The same surface is available to agents as a remote MCP server at https://probie.dev/mcp. It uses Streamable HTTP. Registration and status reads are public; starting an inspection requires the dispatch token returned by registration. Add it to a client:

{
  "mcpServers": {
    "probie": { "type": "http", "url": "https://probie.dev/mcp" }
  }
}
claude mcp add --transport http probie https://probie.dev/mcp
register_inspection_access
Inspecting only: register an email-bound dispatch identity without creating a project.
register_integration
Provision a widget token after collecting the human’s email and consent choice. Requires a retained idempotency key and returns a seven-day claim URL.
inspect_website
Start an inspection with a dispatch token. Returns the id and the URLs to poll and open; reuses live and recent inspections.
get_inspection
The state of an inspection by id, with absolute report and allow URLs when it has finished.
get_integration_skill
The integration skill, with the token filled in when a widget token is passed.
probie://skill
The generic integration skill as a text/markdown resource.

Usage limits apply to inspection and registration across both REST and MCP. A rate-limited response tells the caller when to retry.

Integrations

GitHub
A GitHub App installation gives Probie the repository access it needs to read code and open pull requests. Merge and close events come back through the same App.
Sentry
An inbound webhook turns Sentry issues into Probie tickets, and Sentry evidence is attached to the pull request.
Slack
Notifications when a PR opens, and a /probie slash command that files a ticket from a channel.
Your MCP servers
Per project, you can configure MCP servers that the coding agent is given while it works on your repository.

There is no first-party integration with Jira, Linear, Notion, PagerDuty, or Datadog.

Frequently asked questions

How much does Probie cost?

Website inspection is free and needs no account. The fix pipeline (session capture, triage, and pull requests) is in design-partner access; pricing is agreed per team. Book a demo to talk about yours.

How do I install Probie?

Sign in, create a project, and add the script tag, the Expo package, or the Swift package with your widget token. The install section has the exact snippets, and the agent skill does it for you.

Which frameworks and platforms does Probie support?

Any web app that can load a script tag (server-rendered, static, React, Next.js, Vue), Expo and React Native apps on Expo SDK 50 and later, and Swift apps on macOS 12 and iOS 15 and later. Pull requests work for repositories on GitHub.

What access does Probie need to my repository?

A GitHub App installation on the repositories you choose. The coding agent proposes changes on a probie/* branch, commits as Probie Bot, and opens a pull request. Nothing merges without a person approving it.

What user data does Probie collect?

Behavior events: page views, clicks, rage and dead clicks, stuck loading states, form retries and abandons, JavaScript and fetch errors. Input values are never read, element labels are hashed, query strings are dropped except campaign tags, and no cookies are set. See what the SDKs capture and the privacy policy.

What happens after Probie opens a pull request?

Your team reviews it like any other PR. Probie records whether it was merged or closed. Probie does not verify individual fixes after merge; it keeps a behavior baseline per route and flags the route if the same friction returns.

How is Probie different from Sentry Seer?

Seer starts from an error Sentry already captured. Probie starts from user behavior: rage clicks, dead clicks, abandoned forms, and stuck states that raise no exception. Probie can take Sentry issues as input too. The comparison page has the details.

Can my coding agent use Probie?

Yes. The integration skill installs the SDK, the MCP server at https://probie.dev/mcp runs inspections and fetches the skill, and /llms.txt indexes the documentation in markdown.

Does Probie work without a repository?

Yes. A project without a connected repository still gets session capture and triaged issues on the dashboard, without pull requests. Website inspection needs no account at all.

How do I let the Probie scanner through bot protection?

The scanner signs every request with Web Bot Auth (RFC 9421) and publishes its key. Allow verified bots in Cloudflare, or add an exception for the Signature-Agent header. The scanner page has the exact rules.