inbox-exploration

Exploring the Inbox

The Inbox is where PostHog surfaces signal reports — clusters of related observations (signals) that have been aggregated into a single issue or trend (e.g. "Error rate spiked 3× on /checkout"). Reports come from multiple source products: error tracking, session replay, web analytics, experiments, and integrations like Linear, GitHub, and Zendesk.

Inbox is part of PostHog Desktop, PostHog's agentic surface for engineering teams.

Don't assume the user's project has reports, or that any signal sources are configured — plenty of projects don't have Inbox set up. Always run the setup-check workflow below before answering the user's actual question.

When to use this skill

• "What's in my inbox?" / "What should I look at first?"
• "Show me actionable reports" / "What's PostHog flagged recently?"
• "Are there any reports about <topic / product area>?"
• "What signal sources are configured for this project?"
• The user pastes a report ID or URL and wants context
• "Fix this inbox item" / "turn this report into a PR" / "implement this report" — see Workflow: act on an actionable report
• "Dismiss this" / "snooze this report" / "mark this resolved" / "I've fixed this" — see Workflow: resolve, dismiss, or snooze a report
• "Get this merged" / "run the suggested prompt on this report" — see Workflow: run an action on a report

For deeper investigation, hand off to other skills and tools:

• signals skill — query document_embeddings via HogQL for raw signal text, semantic search across signals, or to inspect every signal that contributed to a report.
• PostHog's product-specific MCP tools — when a report points at a specific error, log line, session, person, or time range, reach for the matching domain tool to pull richer context:
  • Error tracking: query-error-tracking-issues-list, query-error-tracking-issue, query-error-tracking-issue-events for error-tracking-sourced reports
  • Logs: query-logs, logs-count-ranges to find log activity around the issue
  • Session replays: query-session-recordings-list, session-recording-get to find recordings of affected users
  • Persons / activity: persons-retrieve, advanced-activity-logs-list to inspect a specific user's behavior
  • Trends / SQL: query-trends, execute-sql for ad-hoc verification queries

A signal report tells you what PostHog clustered. The product-specific tools tell you the underlying detail — pair them when the user wants to dig in.

Available tools

Tool	Purpose
inbox-reports-list	Paginated list of reports with filters (status, search, etc.)
inbox-reports-retrieve	Full detail for a single report
inbox-reports-claim	Claim or release a report, and optionally attach its implementation PR
inbox-report-artefacts-list	A report's full work log — signal_finding evidence, status judgments, commits, task runs, notes (read-only)
inbox-report-artefacts-retrieve	Full detail for a single artefact (read-only)
inbox-reports-set-state	Resolve (resolved), dismiss (suppressed), or snooze (potential) a single report
inbox-reports-bulk-set-state	Same transition for 1–100 reports in one call (per-id result)
inbox-report-actions-list	The report's agent run actions (Get it merged, suggested prompts) and whether each can start now (read-only)
inbox-report-actions-run	Start one of those actions as a background agent run linked to the report
inbox-ranking-outcomes-list	What each ranking model outcome predicts, with its horizon, cohort and base rate (read-only)
inbox-source-configs-list	Configured signal sources (which products feed the inbox)
inbox-source-configs-retrieve	Full record for a single source config
inbox-source-configs-partial-update	Toggle a source's enabled flag (or adjust its config)
posthog:execute-sql (signals skill)	HogQL access to underlying signals (read the signals skill first)

The inbox-reports-*-list / -retrieve, inbox-report-artefacts-list / -retrieve, and inbox-source-configs-*-list / -retrieve tools are read-only. The exposed writes are inbox-reports-set-state (resolve / dismiss / snooze a single report), inbox-reports-bulk-set-state (the same transition for 1–100 reports in one call), inbox-reports-claim (claim / release / attach a PR), see Workflow: resolve, dismiss, or snooze a report — inbox-report-actions-run (start an agent run from a report action), see Workflow: run an action on a report — and inbox-source-configs-partial-update, which flips a source's enabled flag on or off (e.g. {enabled: false} to stop a source feeding the inbox); -create / -update exist too for standing a source up or replacing it wholesale. Pausing processing is not exposed via MCP.

Terminology

What each report status means (in roughly the order a triage agent should care about):

• ready — judgment finished, actionable assessment available
• pending_input — waiting on user input to proceed
• in_progress — actively being summarized / judged
• candidate / potential — accumulated signals but not yet promoted to a real report
• failed — processing errored
• suppressed — out of the inbox; not surfaced by default. A person or agent dismissed it, or a judge held it back before anyone reviewed it. See Dismissed and held-back reports below
• resolved — the work the report asked for is done. Terminal: a resolved report never re-promotes, so a recurrence starts a fresh report linked back to it. Set automatically when a linked implementation PR merges, or directly via inbox-reports-set-state (see the workflow below)

By default inbox-reports-list excludes suppressed reports and orders results by -is_suggested_reviewer,status,-updated_at — the user's own suggested reports first, then by status, then most recently updated. Refer to the tool's input schema for filter mechanics.

Dismissed and held-back reports

A suppressed report has one of two origins. The inbox shows each origin in its own view, and inbox-reports-list accepts the same split through its view parameter:

view	Lists suppressed reports that…	suppression_source
dismissed	a person or agent dismissed, or that were merged into another report, or whose PR closed unmerged	dismissed
held_back	a judge suppressed before anyone reviewed them	safety_judge, not_actionable, system

Each suppressed row carries two fields that tell the origins apart:

• suppression_source — null unless the status is suppressed.
  • dismissed: someone chose to remove the report. Read dismissal_reason and dismissal_note for the reason.
  • safety_judge: the safety judge marked the report unsafe.
  • not_actionable: the actionability judge marked the report not actionable.
  • system: the pipeline suppressed the report for a different reason. An older report that has no dismissal record and no judge verdict also shows this value.
• suppression_explanation — the judge's explanation when the source is safety_judge or not_actionable. null for the other sources, or when the judge gave none.

Only dismissed is a human or agent decision. The other sources are judge verdicts that nobody has reviewed, and a judge can be wrong. Do not tell the user they hid a held-back report.

Include held-back reports in a review when:

• the user asks what PostHog filtered out, or why an expected report is missing from the inbox
• the user asks for a full review or audit of the inbox, not only the actionable queue
• you deduplicate against the full inbox state before you file or merge a report

For a held-back review, call inbox-reports-list with {"view": "held_back"}. Show the suppression_source and the suppression_explanation for each report, so the user can judge the verdict. If the user decides that a report is valid, restore it with state: "potential". The report goes back to the status it had before the judge held it back. If the user agrees with the verdict, call state: "suppressed" with a dismissal_reason. The report then moves from held_back to dismissed. See Workflow: resolve, dismiss, or snooze a report for both calls.

What "suggested reviewer" means

is_suggested_reviewer: true on a report means the current PostHog user is one of up to three people the report-research flow flagged as best-placed to act on this report. It is the strongest signal you have that a report matters to the user personally, and you should lean on it when triaging.

How the flag is produced:

1. While researching a report, the agent identifies the GitHub commits most relevant to the underlying signals (e.g. commits that touched the failing code path).
2. It fetches the authors of those commits, weights earlier/more-relevant commits more heavily, and keeps the top three GitHub logins. These get persisted as a SUGGESTED_REVIEWERS artefact on the report.
3. At read time, those GitHub logins are mapped back to PostHog users via each org member's linked GitHub identity (social auth or GitHub integration). If the current viewer's linked GitHub login is one of them, is_suggested_reviewer flips to true for that report. A reviewer can also be stored by PostHog user_uuid (a scout or a person naming an org member directly), which matches the viewer without any GitHub link. The flag is forced to false on a failed report and on a ready report judged not_actionable, whatever reviewers they carry, so read suggested_reviewers directly when auditing routing.

Practical implications for triage:

• A true value means "you are a suggested reviewer for this report": a plausible owner, not an assignee. When the pipeline derived the reviewers, that usually means you wrote (or recently touched) the relevant code; when a scout or a person named you by user_uuid, it means they judged you the owner. It's a recommendation, not authoritative.
• A false value doesn't mean the report is irrelevant — it can mean (a) someone else owns the code, (b) the suggested logins came from commit history and no org member has that GitHub account linked (a reviewer set by user_uuid doesn't have this problem), or (c) the source material wasn't tied to a specific repo / commits.
• If the user asks "what should I look at?", lead with is_suggested_reviewer: true reports: these are the ones routed to the user as a likely owner. Mention the rest as a secondary group rather than mixing them in.
• If the user has no suggested reports but the inbox isn't empty, say so explicitly ("nothing in the inbox is tied to code you've authored recently") rather than pretending the top of the list is personalized.

Workflow: handling an empty or unconfigured inbox (read first)

Run this check whenever a user asks about the inbox for the first time in a session, or any time inbox-reports-list returns count: 0. The diagnosis decides what to say next.

Step 1 — Look at source configs

inbox-source-configs-list
{ "limit": 50 }

Three meaningful cases:

Case A — no source configs at all (count: 0)

The user hasn't onboarded to Inbox / signals. Don't pretend the inbox has data. Tell the user plainly that Inbox needs signal sources to be set up first, and that the recommended way to do this is to install PostHog Desktop at https://posthog.com/desktop. Example response:

Your project doesn't have any signal sources configured yet, so the Inbox is empty. Inbox surfaces issues and trends that PostHog automatically clusters from sources like error tracking, session replay, GitHub, Linear, and Zendesk. The fastest way to set this up is to install PostHog Desktop — once it's connected, signals will start flowing in and reports will appear in your inbox over the next day or so.

Stop here unless the user wants to discuss setup. Don't run further inbox tools — they'll all be empty.

Case B — source configs exist but all are enabled: false

Sources have been set up at some point but are currently turned off. Tell the user no signals are flowing right now. You can re-enable a source directly with inbox-source-configs-partial-update { "id": "<source_config_uuid>", "enabled": true } (confirm with the user first), or they can flip it on from the project's signals settings. Don't go fishing for reports — anything still there is stale.

Case C — at least one source config is enabled: true

Setup looks healthy. If inbox-reports-list still returns nothing, it's most likely "give it time" — signals are flowing but nothing has clustered into a report yet. Tell the user that, briefly list which sources are active (e.g. "you have GitHub and error tracking enabled"), and offer to check back later or to drop into the signals skill to look at raw signal volume.

If any source config has status: "failed", surface that as part of your reply — that source isn't producing signals right now, which may explain a thin inbox.

Step 2 — Only then proceed to the user's actual question

If Step 1 found a healthy setup and at least one report exists, continue with the triage / drill / filter workflows below.

Workflow: triage what's actionable

When the user asks "what should I look at?" or "what's actionable?":

Step 1 — Pull the ready/in-progress queue

inbox-reports-list
{
  "status": "ready,in_progress,pending_input",
  "limit": 20
}

If count: 0 comes back, jump to the empty/unconfigured workflow above before saying "your inbox is empty" — the right reply depends on whether sources are configured.

A claimed report keeps its pipeline status, so this queue also returns work someone else already owns. Add "unclaimed": true when the user is asking what is free to pick up, and "assignee": "me" to list what the caller already owns and may want to resume.

Step 2 — Summarize by source and actionability

For each report, the response includes:

• id, title, summary
• status, priority, actionability (note: null for reports still in pending_input / candidate — judgment hasn't run yet)
• signal_count, total_weight — how much underlying evidence drove the report
• source_products — which product(s) the underlying signals came from
• is_suggested_reviewer — whether the current user is a suggested reviewer for this report (see "What 'suggested reviewer' means" above — it's based on GitHub commit authorship of the relevant code, mapped to PostHog users via linked GitHub identity)
• pull_requests — if a PR has been opened against this report
• work_state — unclaimed, working, in_review, or done
• assignee — who claimed the report (a user, an internal task, or an external agent), or null when nobody has. Say so when you list a report someone else owns, so it doesn't read as free work
• _posthogUrl — clickable deep-link to the report; always include this in your response

Group the results so the user can scan quickly. Lead with reports where is_suggested_reviewer: true — those are the ones tied to code the current user has authored — and only then fall back to priority groupings for the rest:

## Inbox — 8 actionable reports

⭐ Suggested for you (1)
- Checkout error rate spiked 3× — error_tracking, 47 signals (you're a suggested reviewer)
  <_posthogUrl>

🔴 High priority (2 more)
- Session replays on /pricing show repeated rage clicks — session_replay, 12 signals
  <_posthogUrl>
…

🟠 Medium priority (4)
…

If no reports come back with is_suggested_reviewer: true, say so explicitly before listing the rest — don't silently drop the section.

Step 3 — Offer the drill-down

End with a clear hand-off: "Want me to dig into the checkout errors?" → call inbox-reports-retrieve for the full report, then optionally hop to the signals skill to look at the underlying signal text.

Workflow: drill into a specific report

When the user pastes an Inbox URL or report ID:

inbox-reports-retrieve
{ "id": "<report_uuid>" }

Returns the full record including signals_at_run and artefact_count. Then read the report's work log:

inbox-report-artefacts-list
{ "report_id": "<report_uuid>" }

This returns the report's evidence (signal_finding), the judgments behind its status/priority/actionability (safety_judgment, actionability_judgment, priority_judgment, repo_selection, suggested_reviewers), and its work-log (commit, task_run, note) — the curated "why it exists and what's been done" view, in one read-only call.

Use the signals skill only when you need the raw signal text beyond the curated findings:

1. Use inbox-reports-retrieve to get the report metadata + id
2. Use inbox-report-artefacts-list for the curated evidence, judgments, and work-log
3. Use the signals skill's Example 2 (fetch all signals for a specific report) — pass the report ID as metadata.report_id in the HogQL query — only for the raw underlying signal text

The layers complement each other: inbox-report-artefacts-list gives you the curated/judged view (evidence + judgments + PR/task-run history), and the signals skill lets you inspect the raw observations that produced it.

Workflow: act on an actionable report

When the user wants to do something about a report — "fix this inbox item", "turn this into a PR", "implement this" — not just read it. A ready report with actionability: immediately_actionable is the usual candidate. The discipline that matters here: a report is a diagnosis, not ground truth — verify it against the actual code before you implement. Reports from signals_scout (and any LLM-research source) are especially worth double-checking; their summary often reads as a confident root-cause with file and function names, but it can be stale or wrong.

Step 1 — Retrieve, check existing work, and claim it

inbox-reports-retrieve
{ "id": "<report_uuid>" }

Before doing any work, look at:

• already_addressed — if true, the fix may already be in flight or merged; confirm with the user before duplicating it.
• pull_requests — inspect existing PRs before opening another; a report can have a stack or PRs across repositories.
• work_state and assignee — show whether someone else has already picked it up. A takeover is allowed, but make it deliberate rather than overlooking active work.
• status — only ready reports carry a finished judgment. A candidate / pending_input report hasn't been researched yet; don't implement off a half-formed summary.

Before starting research or implementation, claim the report:

posthog:inbox-reports-claim
{ "report_id": "<report_uuid>" }

Save the returned assignee.claim_id and pass it on subsequent work updates and artefact writes. Taking over another actor requires takeover=true; stale claim IDs are rejected. The claim is attributed to the current internal task or external MCP client. Claims do not expire, so release the report whenever you walk away without landing a fix — including when you dismiss it instead. Release clears ownership only; an attached pull request stays on the report, and release works from any status, so a dismissed report can be released too.

Step 2 — Verify the diagnosis against the code (do not skip)

Start by reading the report's work log — its evidence and the judgments behind it:

inbox-report-artefacts-list
{ "report_id": "<report_uuid>" }

This surfaces the signal_finding evidence, the status/priority/actionability judgments, and any commit / task_run history — exactly the "why it exists and what's already been done" you need before touching code. Then the report's summary will name files, functions, and sometimes line numbers. Open them and confirm the claim holds — that the cited code exists, still looks the way the report describes, and actually produces the described failure. As a deeper fallback, pull the raw underlying signals via the signals skill (metadata.report_id) if you need the signal text behind the curated findings. If the diagnosis doesn't hold up, say so and stop — a wrong report is itself a useful finding (and a candidate for dismiss below), not a license to write a speculative fix. Release the claim you took in Step 1 before you stop, so the report returns to the unclaimed view instead of reading as active work nobody is doing:

posthog:inbox-reports-claim
{ "report_id": "<report_uuid>", "claim_id": "<claim_uuid>", "release": true }

Step 3 — Scope the fix to the right layer

• If source_products includes signals_scout and the root cause is in a scout's own behavior (the prompt it runs, a threshold it uses), the better fix is often the scout's SKILL.md, not the harness. Note that per-team custom scouts live in the user's Skills Store, not this repo, so the fix site may be out of reach of a repo PR — flag that to the user.
• Otherwise treat it like any normal change: follow the repo's conventions (CLAUDE.md, area-specific skills), make the change minimal, and add a regression test that would have caught the reported failure.

Step 4 — Open the PR and attach it

Open the PR following the repo's PR conventions, then attach it to the report:

posthog:inbox-reports-claim
{
  "report_id": "<report_uuid>",
  "claim_id": "<claim_uuid>",
  "pull_requests": ["https://github.com/example/repository/pull/123"]
}

PR links are additive and retries do not duplicate them. Send every known PR together so completion considers the entire stack. The same PR may be attached to multiple reports. Connected repositories receive immediate state validation and webhook updates. PRs from unconnected repositories are accepted with unknown state, so resolve those reports manually after the work lands. Also reference the report's _posthogUrl in the PR description so the loop is traceable from either side.

Don't resolve a report because you opened a PR. A report resolves when all linked PRs are closed or merged and at least one merged. If all closed without merging, it is suppressed. Any open, draft, or unknown PR prevents automatic completion. Resolving by hand at PR-open time asserts work that hasn't landed, and a reviewer looking at the inbox can't tell the difference. Manual resolve is for fixes a PR merge will never cover — a skill-body change, a config change, a NO_REPO report — see the workflow below.

Workflow: run an action on a report

A report can offer actions that start an agent run, the same ones the inbox shows as buttons: Get it merged (get_it_merged) fixes CI on the report's open, approved pull request and merges it, and each suggested prompt (suggested_prompt) sends one prompt the report suggests. Use these instead of tasks-create-and-run: a run started here is linked to the report, so it shows in the report's runs, counts toward the report's task limit, and gets the report's code access rules. The two tools are rolling out behind a flag, so they can be missing from your tool list. If they are, send the person to the report's _posthogUrl to press the button.

Step 1 — List the actions

posthog:inbox-report-actions-list
{ "report_id": "<report_uuid>" }

Every action comes back, available or not. Pick one with available: true. When an action is not available, disabled_reason says why (no approved open PR, AI data processing not approved, and so on): tell the person rather than trying to run it. text is the message the run gets as its first request, so show it when the person wants to know what the agent will be asked to do.

Step 2 — Confirm, then run it

Starting a run creates a task that spends the organization's usage, and Get it merged can merge a pull request. Confirm with the person before you run an action they did not ask for by name.

posthog:inbox-report-actions-run
{ "report_id": "<report_uuid>", "action": "suggested_prompt", "suggested_prompt_index": 0 }

Pass suggested_prompt_index only for suggested_prompt, with the value from the list. A 201 returns task_id, run_id, and task_url. Each successful call creates a new task, so do not retry it. If run_error is set, the task exists but its run did not start: report the error and do not start a second one.

Step 3 — Follow the run

The run works in the background. Follow it with tasks-runs-retrieve using task_id and run_id, and give the person task_url. Nobody can answer questions in a background run, so when the agent needs a decision it writes a note to the report's work log. Read new notes with inbox-report-artefacts-list.

Errors

Every refusal carries a code. Do not retry any of them unchanged.

Status	code	What to do
400	report_action_unavailable	The action is not available now. Tell the person the detail.
403	report_action_unavailable	The organization has not approved AI data processing. An admin turns it on in settings.
403	report_action_sandbox_refused	A task sandbox cannot start report actions. Ask a person to start it from their own session.
409	report_action_run_active	A merge run is already working on the report. Follow the task_id and run_id in the body.
429	signal_report_task_cap	The report reached its task limit. Work with the runs it already has.
429	throttled, usage_limit_exceeded	A per-user or organization usage limit fired. Wait until it clears.
402	self_driving_free_trial	The organization is on a Self-driving free trial, which cannot open pull requests.
404	none	The report has no suggested prompt at that index. List the actions again and use a fresh index.

Workflow: resolve, dismiss, or snooze a report

Three outcomes, one tool. Pick by what actually happened to the underlying issue:

The issue is…	State	Why
fixed by work you did	resolved	terminal; the report has served its purpose
not real, or not worth fixing	suppressed	dismissed from the inbox, with the reason recorded
real but deferred, or fixed by something else	potential	back into the pipeline; reappears if it recurs

inbox-reports-set-state
{
  "id": "<report_uuid>",
  "state": "suppressed",
  "dismissal_reason": "analysis_wrong",
  "dismissal_note": "Verified against products/foo/bar.py — the cited code path can't reach this state."
}

• state: "resolved" marks the requested work done, and is terminal — a recurrence starts a fresh report rather than reopening this one. Allowed from ready / pending_input, or from a suppressed report that held one of those when archived; anything else returns 409. Only resolve work that has actually landed. A fix shipping as a PR resolves itself on merge (see Step 4); resolve by hand only where the webhook can never reach — a skill-body edit, a config change, a NO_REPO report. Record dismissal_reason: "fixed_outside_posthog" for that (the fix landed without a pull request); use pr_merged when a pull request with the fix was merged but did not resolve the report on its own; reserve already_fixed for an issue fixed before the report was filed. Don't use already_fixed + state: "potential" when you did the fixing: that pairing means "fixed by something else, might recur", so the report comes back.
• state: "suppressed" dismisses the report from the inbox; state: "potential" snoozes it back into the pipeline. When snoozing, snooze_for: <N> holds it until it accumulates N more signals.
• dismissal_reason must be one of the server-validated canonical codes — already_fixed, report_unclear, analysis_wrong, wrong_assignee, wrong_repo, wontfix_intentional, wontfix_irrelevant, fixed_outside_posthog, no_action_needed, pr_merged, other — an unlisted value returns 400. Reach for other plus a dismissal_note for anything that doesn't fit a specific code. dismissal_note is free-form (≤ 4000 chars). Both persist as a DISMISSAL artefact, so the rationale survives later transitions — always include them, on a resolve too, so a future reader knows why.
• wrong_repo means the agent researched the report against the wrong repository. Pair it with corrected_repository ("owner/repo", case-insensitive; only allowed with this reason) naming the right one: the correction is recorded on the dismissal and fed into every future repository selection for the project, and when the named repository is connected to the project it also becomes this report's own next selection. Without a usable correction the report's selection is cleared instead, so a restored report re-selects rather than reusing the rejected repository.
• wrong_assignee means the report reached the wrong person or team. It is routing feedback, not a verdict that the report itself was wrong.
• On a dismiss, snooze, or restore, the dismissal_note is also forwarded as a steering note to the scout that filed the report, which every scout run reads at cold start, so what you write there is what stops the same report being filed again. Write it for that reader: name the evidence that settles it, not just the verdict. A resolve is not forwarded, since it says the report did its job rather than that filing it was wrong; that note stays on the report. A wrong_repo dismissal is forwarded even with no note: the steering note names the repository the report wrongly targeted and, when you passed one, the corrected_repository. Forwarding needs the same skill-editing access as leaving a scout note by hand, so on a project where you lack it the note still lands on the report but does not reach the scout.
• It's a destructive, non-idempotent transition and returns 409 if it isn't allowed from the report's current status (and 400 if dismissal_reason isn't a canonical code). Confirm with the user before suppressing, and capture why in the note — a dismissal with no rationale is worse than none. A report you dismissed because the diagnosis was wrong (Step 2 above) is the textbook case: suppress it with analysis_wrong and the evidence in the note. A refunded report is frozen: snooze and resolve both come back 409 / skipped with an explanatory detail.
• To transition several reports at once, use inbox-reports-bulk-set-state with an ids array (1–100). It applies the same state / dismissal_reason / dismissal_note / corrected_repository / snooze_for to every id and returns a per-id results list (in request order) plus a transitioned_count / skipped_count / failed_count / not_found_count summary. Each id is processed independently, so the call returns 200 even on partial failure — an id whose transition isn't allowed comes back as skipped (the single-report 409) while the rest go through. Inspect the per-id outcomes rather than assuming the whole batch succeeded.

Workflow: filter by topic or source

"Are there any reports about ?" — start with search:

inbox-reports-list
{
  "search": "checkout",
  "status": "ready,in_progress,pending_input",
  "limit": 20
}

search matches title and summary. If the user is asking about a product area rather than a keyword, use source_product:

inbox-reports-list
{
  "source_product": "session_replay,error_tracking",
  "limit": 20
}

If the keyword search returns nothing meaningful, hand off to the signals skill — semantic search over signal text via embedText() will catch reports the keyword filter missed.

Model predictions as building blocks

The inbox ranking model predicts outcomes for each report. Each row of inbox-reports-list and inbox-reports-retrieve carries them in ranking:

"ranking": {
  "status": "scored",
  "scored_at": "2026-10-24T05:12:00Z",
  "predictions": [
    { "outcome": "open", "probability": 0.21, "lift": 1.5, "readable": true },
    { "outcome": "action", "probability": 0.09, "lift": 1.4, "readable": true },
    { "outcome": "fix", "probability": 0.3, "lift": 2.7, "readable": true }
  ]
}

• open: a person opens the report. action: a person or their agent acts on it. fix: someone fixes the problem it describes. Call inbox-ranking-outcomes-list for the current meaning, horizon and base rate of each outcome, because they follow the served model.
• A prediction says what may happen, never what did. A high fix probability does not mean the report is fixed: read status and the PR fields for that.
• A lift is the probability divided by the outcome's base rate. 1.0 is an average report, 2.7 is 2.7x as likely. Compare lifts across outcomes. Raw probabilities do not compare, because each outcome has its own base rate.
• readable: false means the training run could not measure the holdout AUC of that outcome. Rank and filter on that outcome with caution.
• status is scored, stale (the title or summary changed after scoring, so the predictions describe the old text), unscored (no score yet, which is not a low score), or not_available (the user cannot see the ranking model, so ordering and filtering by it return 400).
• inbox-reports-retrieve also names the model that made the predictions. Predictions from different models do not compare.

Recipes:

• Likely to get a fix: view=actionable with ordering=-ranking_fix.
• Hidden gems: priority=P3,P4 with ranking_min_lift=fix:2.
• Probably noise: reports with a low lift on all three outcomes are candidates to dedupe or dismiss. Read them before you act: a low lift is a hint, not a verdict.
• Add search or source_product to any recipe to narrow it to a topic.

ranking_min_lift and ranking_min_probability take comma-separated <outcome>:<value> pairs, and a report must meet every pair. Unscored and stale reports never match.

Caveats:

• The predictions are model estimates, and the top end over-predicts. Use them to rank and filter, not as literal odds.
• Most fix positives are also action positives, so do not add the two together.

Workflow: review configured sources

When the user asks "which signal sources are set up?" or "is hooked up?":

inbox-source-configs-list
{ "limit": 50 }

Each entry returns id, source_product, source_type, enabled, status, plus timestamps. For full details (including the per-source config JSON — recording filters, evaluation IDs, etc.):

inbox-source-configs-retrieve
{ "id": "<source_config_uuid>" }

Integration credentials live in a separate Integration model — they are not in the config blob, so it's safe to summarize the contents back to the user.

The status field reflects the underlying data import or workflow:

• running / completed — feeding signals normally
• failed — the source isn't currently producing signals; flag this to the user

To turn a source on or off, use inbox-source-configs-partial-update with the config's id and { "enabled": true | false } — only the fields you pass change, so this is the right tool for a plain toggle (-update replaces the whole record; -create stands up a new source). Confirm with the user before flipping a source, since enabling one drives signal processing and spend.

inbox-source-configs-partial-update
{ "id": "<source_config_uuid>", "enabled": false }

Tips

• Check setup before assuming the inbox is empty. If inbox-reports-list returns count: 0, call inbox-source-configs-list first — no sources means the user needs to install PostHog Desktop to start receiving signals; sources-but-no-reports means signals are flowing but nothing has clustered yet
• Always surface _posthogUrl so the user can click through to the report
• The default ordering already prioritizes the user's suggested reports — don't reorder unless asked
• priority and actionability are null for reports still in pending_input or candidate status; this is expected, not a bug — judgment hasn't run yet
• suppressed reports are excluded by default. Pass view: "dismissed" for reports someone dismissed, view: "held_back" for reports a judge held back, or status: "suppressed" for both. Read suppression_source before you describe why a report left the inbox
• The inbox writes exposed via MCP are inbox-reports-set-state (resolve / dismiss / snooze one report), inbox-reports-bulk-set-state (the same for 1–100 reports), inbox-reports-claim (claim / release / attach a PR), and inbox-source-configs-partial-update (toggle a source's enabled flag). To act on a report (implement a fix), claim it, verify the diagnosis against the code, then open and attach a PR — see Workflow: act on an actionable report. A PR-backed fix is resolved automatically when the PR merges, so don't resolve it by hand at PR-open time. Always also surface the _posthogUrl deep-link
• Never implement a report's fix straight from its summary. Reports — especially signals_scout ones — are LLM diagnoses; confirm the cited files / functions / behavior in the actual code before writing a fix. A report that doesn't hold up is a dismissal candidate, not a fix
• For "what kinds of signals exist?" or "what's been happening recently across all sources?", drop into the signals skill — the report layer hides individual observations; you need HogQL on document_embeddings to see them
• Source configs don't have per-record deep-links — they live behind project settings, so inbox-source-configs-retrieve returns no _posthogUrl. Don't confuse them with reports