particle-pro MCP server
pro.particle/particle-proparticle.prostreamable-httpv1.0.0Scanned
Podcast intelligence for agents: transcripts, clips, speaker diarization, mention tracking.
44 tools: 6 can delete or cancel things, 1 do something that can't be undone, 3 change things and 34 only read.
- Reads private data · 1
- Reads text others write · 40
- Can send data out · 1
- 13 findings
Tools listed without sign-in. Remote posture
With Anlyon
6 tools here can delete or cancel things and 1 does something that can't be undone. Govern them.
- Anlyon lists the tools and adopts none.
- Each tool you adopt gets approvals and receipts.
- Your agent never holds the key.
A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.
What the particle-pro MCP server can do
The particle-pro MCP server is published by particle.pro, a domain the MCP Registry verified. It has 44 tools. It can delete or cancel things (6 tools: particle_alert_create, particle_alert_delete, particle_alert_update, particle_call and 2 more), do things that cannot be undone, such as sending, paying or publishing (particle_report_create) and create or change data (3 tools: particle_alert_preview, particle_podcast_request_transcription and particle_topic_browse). 34 tools only read.
1 tool reads private data (particle_alert_get); 40 tools bring in text other people can write (particle_alert_create, particle_alert_get, particle_alert_update and 37 more); 1 tool can send data out of your system (particle_report_create). On its own it has all three parts of a prompt-injection exfiltration path: private data, text others write, and a way out.
The fixed checks matched 13 findings (long-description, annotation-conflict and credentials-mention). Each one comes with the text it matched.
Its remote endpoint lists its tools without sign-in, and its tools changed 2 times since Anlyon Radar first saw them.
Last scanned Nov 19, 2026, version 1.0.0.
Tools
Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.
44 tools
Deletes or cancels 6Claude Code: deny
particle_alert_createCreate an alert that watches a single entity and sets up recurring email delivery to external recipients whenever it is mentioned on a podcast episode (kind=ENTITY_MENTION) or appe…Reads text others write1 finding
Why it is in this group
- The name "particle_alert_create" says "create": a word for a change.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Info
The description is 3,201 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...rt's definition and its matched results are stored as part of the alerts feature."
Description, as the server wrote it Create an alert that watches a single entity and sets up recurring email delivery to external recipients whenever it is mentioned on a podcast episode (kind=ENTITY_MENTION) or appears as a speaker (kind=PODCAST_SPEAKER). Pass the entity slug from a resolve tool — resolve a name with particle_entity_resolve, then create the alert with the slug it returns. An alert watches exactly one entity; to cover several entities, call this tool once per entity. An active alert emails future matches to its configured recipients at the selected delivery cadence until paused or deleted. Only recipients verified for your organization receive alert emails; pending recipients may be saved but stay silent until verified. When a name has no entity slug, or its entity has no podcast coverage (a startup known by a brand that differs from its legal name, a product, a drug, a code word), create a kind=KEYWORD_MENTION alert with `keyword` instead of `entities`. It fires whenever the phrase is spoken — the match particle_podcast_search_transcripts makes for a double-quoted keyword_search phrase (words adjacent and in order), not the looser unquoted match — so also set `description` to say what the phrase means; that is how same-name mentions of something else are filtered out. Use the optional `filters` object to narrow what gets surfaced on every channel (matches list, realtime email, daily/weekly digest). Four independent axes: `languages` (BCP-47-like tags like ['en','pt-BR'] — empty means all languages), `relevance` (EVERYTHING returns on-target + incidental matches, RELEVANT narrows to on-target only — dropping passing mentions), `source_popularity` (ANY keeps every source, POPULAR keeps only matches from podcasts in the top 5% by chart popularity), and `speaker_roles` (PODCAST_SPEAKER alerts only — REPLACES the default appearance set GUEST/PANELIST/CORRESPONDENT/AUDIENCE/SOUNDBITE_SPEAKER; sending it on an ENTITY_MENTION alert errors with unprocessable_entity). ENTITY_MENTION alerts also take `speaker_statement_characteristics`, which fires only on mentions said a certain way: {"sentiment": ["negative"]} for negative mentions of a company, {"specificity": ["specific"], "temporal_orientation": ["future"]} for predictions about it, {"certainty": ["confident"]} for confident claims. Each mention line in the alert's matches carries its labels. Billing: creating an active alert can move an eligible organization's subscription from its credit/trial phase to paid fixed-fee billing. Explain this possible billing change and obtain the user's explicit confirmation before creating an active alert. Creating a paused alert (is_active=false) does not trigger this billing transition. After creation the alert immediately backfills matches from the past week (visible via particle_alert_list_matches) without sending emails for them. To see what an alert would catch BEFORE committing, use particle_alert_preview first. The created alert's id feeds particle_alert_get, particle_alert_update, particle_alert_delete, and particle_alert_list_matches. Alerts are not covered by zero data retention: the alert's definition and its matched results are stored as part of the alerts feature.
Annotations the server declares
- destructiveHint: true
- openWorldHint: true
- readOnlyHint: false
particle_alert_deleteDelete an alert.No findings
Why it is in this group
- The name "particle_alert_delete" says "delete": a word for removing or ending something.
- The server marks it destructive (destructiveHint: true).
Description, as the server wrote it Delete an alert. This is a soft delete: the alert stops producing matches and disappears from particle_alert_list, but its past matches and deliveries are retained for audit. To pause an alert instead of removing it, use particle_alert_update with is_active=false. Only the alert's creator or an organization OWNER or ADMIN can delete it; an API key acts as the user who created the key. Other callers get a 403.
Annotations the server declares
- destructiveHint: true
- openWorldHint: false
- readOnlyHint: false
particle_alert_updateUpdate an existing alert.Reads text others writeNo findings
Why it is in this group
- The name "particle_alert_update" says "update": a word for a change.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Update an existing alert. Only the fields you pass change; the entities and notifications lists, when provided, replace the whole set (pass a single entity slug from the resolve tools, same as particle_alert_create — an alert watches exactly one entity). A KEYWORD_MENTION alert takes a new `keyword` instead of `entities`. Use is_active to pause or resume an alert without deleting it. An alert's kind is fixed at creation — to change it, create a new alert. Notification changes affect future recurring email delivery to external recipients; resuming an alert restarts delivery to its configured destinations. Alert emails follow delivery_cadence until paused or deleted. Only recipients verified for your organization receive alert emails; pending recipients may be saved but stay silent until verified. The optional `filters` object replaces the alert's filter set wholesale — omit to leave the existing filters unchanged, send {} to clear all filters. Same axes as particle_alert_create.filters: `languages`, `relevance` (EVERYTHING/RELEVANT), `source_popularity` (ANY/POPULAR), `speaker_roles` (PODCAST_SPEAKER alerts only — sending it on an ENTITY_MENTION alert returns unprocessable_entity), and `speaker_statement_characteristics` (ENTITY_MENTION alerts only; it applies to matches detected after the update). Alerts are not covered by zero data retention: the alert's definition and its matched results are stored as part of the alerts feature.
Annotations the server declares
- destructiveHint: true
- openWorldHint: true
- readOnlyHint: false
particle_callDispatch any public Particle tool by name.Reads text others writeNo findings
Why it is in this group
- The name "particle_call" says "call": a word for a change.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Dispatch any public Particle tool by name. Compatibility fallback for harnesses that block calling tools that weren't advertised on tools/list — every public Particle tool is executable by name, so prefer calling discovered tools directly when your harness allows it. Identical metering and plan gating apply either way. Use particle_catalog to discover tool names and input schemas. A tool particle_catalog lists but your tools/list lacks (client lists go stale after a deploy) is callable here: never report it unavailable.
Annotations the server declares
- destructiveHint: true
- openWorldHint: true
- readOnlyHint: false
particle_report_deleteDelete a saved Radar report for everyone in the project.Reads text others writeNo findings
Why it is in this group
- The name "particle_report_delete" says "delete": a word for removing or ending something.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Delete a saved Radar report for everyone in the project. Any member of the project's organization may delete one. Its Radar link stops opening it, so do this only when the user asks.
Annotations the server declares
- destructiveHint: true
- openWorldHint: true
- readOnlyHint: false
particle_report_updateChange a saved Radar report: rename it, replace its subjects, or change its period, sources, sort, episode cap, omitted sections or hidden episodes.Reads text others writeNo findings
Why it is in this group
- The name "particle_report_update" says "update": a word for a change.
- The input addresses people (input.to): what it sends cannot be taken back.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Change a saved Radar report: rename it, replace its subjects, or change its period, sources, sort, episode cap, omitted sections or hidden episodes. Only the fields you pass change. `subjects` replaces the whole list, so pass every subject the report should keep. Setting `period` clears an explicit from/to range, and setting from/to clears the period. Every member of the project's organization sees the change. Returns the updated report and its Radar link.
Annotations the server declares
- destructiveHint: true
- openWorldHint: true
- readOnlyHint: false
Can't be undone 1Claude Code: ask
particle_report_createSave a Radar report in your project: a page comparing one to four people, companies, topics or keywords side by side, with their podcast mentions over time, every mention linked to…Reads text others writeCan send data outNo findings
Why it is in this group
- The name "particle_report_create" says "create": a word for a change.
- The input addresses people (input.to): what it sends cannot be taken back.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a destination (input.to): what the tool writes goes there.
Description, as the server wrote it Save a Radar report in your project: a page comparing one to four people, companies, topics or keywords side by side, with their podcast mentions over time, every mention linked to the minute, and their news coverage. Returns the report's id and its Radar link; give the user the link, since the page is where the report is read (and downloaded as a PDF). Every member of the project's organization can open and edit it. Resolve each person, company or topic first with particle_entity_resolve, particle_person_resolve or particle_company_resolve and pass the slug as `entity`; use `keyword` for a name with no slug. The period defaults to the last three months and the sources to podcasts and news. Use it when the user asks for a report, or to compare or share coverage. To answer a question about coverage now, use the podcast tools instead: a report is a page to open, not data returned to you. The id feeds particle_report_get, particle_report_update and particle_report_delete.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: false
Changes things 3Claude Code: ask
particle_alert_previewPreview how often an alert would fire BEFORE creating it.1 finding
Why it is in this group
- The name "particle_alert_preview" says "preview": a word for reading.
- The server marks it as not read-only (readOnlyHint: false).
Findings
- Warn
The server marks "particle_alert_preview" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"openWorldHint":false}; The name "particle_alert_preview" says "preview": a word for reading.
Description, as the server wrote it Preview how often an alert would fire BEFORE creating it. Sweeps the past N days (default 7, max 30) for the given entity (or keyword, for kind=KEYWORD_MENTION) and returns the total match count, a per-day breakdown, and a small sample of the most recent matches with episode context. Use this to size an alert (REALTIME vs DAILY vs WEEKLY cadence) or to confirm the entity slug watches the right thing, then call particle_alert_create with the same entity slug (for KEYWORD_MENTION, the same keyword instead). Pass the same `filters` you plan to save so the estimate matches what the alert would surface — the languages and speaker_roles axes narrow the sweep; relevance and source_popularity are read-time projections that don't, so the count is an upper bound when relevance=RELEVANT. Starts a background sweep and caches its progress and results; it does not create an alert or send notifications.
Annotations the server declares
- destructiveHint: false
- openWorldHint: false
- readOnlyHint: false
particle_podcast_request_transcriptionRequest the transcription of a back-catalogue episode: one discovered in its podcast's feed but not yet transcribed, which particle_podcast_list_episodes (transcript_status=request…Reads text others writeNo findings
Why it is in this group
- The name "particle_podcast_request_transcription" says "request": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Request the transcription of a back-catalogue episode: one discovered in its podcast's feed but not yet transcribed, which particle_podcast_list_episodes (transcript_status=requestable, with podcast_slug) and particle_podcast_get_episode mark requestable. Its transcript, segments, speakers, entities and mentions do not exist until it is transcribed. Billing: the request that queues the episode costs $0.05 per episode on every plan, charged in USD and never drawn from the included requests, and needs overage billing turned on (overage_required otherwise). Confirm the charge with the user before requesting. Every other outcome is billed as an ordinary lookup: an episode your organization already requested (the existing request is returned), one another organization's request already queued, or one we already hold. It returns at once with the request's state: queued, admitted (being transcribed), transcribed, or failed (failure_reason says why; the charge is refunded). Transcription usually takes 5 to 10 minutes. Poll with particle_podcast_get_transcription_request, which is free; never call this tool again to poll. Once transcribed, the episode keeps its slug and every episode tool serves it: particle_podcast_get_episode, particle_podcast_find_mentions with episode_slug, and particle_podcast_search_transcripts.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
particle_topic_browseNavigate the topic taxonomy.Reads text others write1 finding
Why it is in this group
- The name "particle_topic_browse" says "browse": a word for reading.
- The description's first verb is "navigate": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe name "particle_topic_browse" says "browse": it reads web pages, which anyone can write.
Findings
- Warn
The server marks "particle_topic_browse" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "particle_topic_browse" says "browse": a word for reading.
Description, as the server wrote it Navigate the topic taxonomy. Without `parent_slug`, returns the top-level roots (Politics, Business, Technology, etc.). With `parent_slug` set, returns the direct children of that topic. Topic slugs use a `parent/child` convention (e.g. `politics/elections`) and let agents browse the hierarchy to find well-named categories. To find a topic by name instead of walking the tree, pass `query` (e.g. `artificial intelligence`): exact names rank first, then prefixes, then substrings (for a word of 3+ characters), each by story coverage, and `parent_slug` narrows the search to that subtree. The same name often sits under several parents, so read the ancestry before picking a slug. Topic slugs feed the `topic_slug` filters on `particle_podcast_resolve` and `particle_podcast_list_guests`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: false
- readOnlyHint: true
Only reads 34Show 34 read-only tools
particle_alert_getFetch a single alert's full configuration — title, kind, cadence, watched entities (with names), notification emails, and any active filters (languages, relevance, source_popularit…Reads private dataReads text others writeNo findings
Why it is in this group
- The name "particle_alert_get" says "get": a word for reading.
What it can reach
- private-dataThe description's first sentence says "fetch" and "email": it reads mail.
- untrusted-inputThe description's first sentence says "fetch" and "email": it reads inbound email, which other people can write.
Description, as the server wrote it Fetch a single alert's full configuration — title, kind, cadence, watched entities (with names), notification emails, and any active filters (languages, relevance, source_popularity, speaker_roles). The `filters` section is omitted when the alert carries none. By default the response is just the configuration; request include=['matches'] to embed the most recent matches it has caught and include=['deliveries'] for the email audit log. For the full, paginated match history with transcript excerpts, use particle_alert_list_matches.
Annotations the server declares
- destructiveHint: false
- openWorldHint: false
- readOnlyHint: true
particle_alert_listList the alerts in your project, newest first.No findings
Why it is in this group
- The name "particle_alert_list" says "list": a word for reading.
Description, as the server wrote it List the alerts in your project, newest first. Each entry carries the alert `id` — feed it into particle_alert_get for full configuration, particle_alert_list_matches for what it has caught, or particle_alert_update / particle_alert_delete to manage it.
Annotations the server declares
- destructiveHint: false
- openWorldHint: false
- readOnlyHint: true
particle_alert_list_matchesList the matches an alert has caught, newest first — the payoff of an alert.No findings
Why it is in this group
- The name "particle_alert_list_matches" says "list": a word for reading.
Description, as the server wrote it List the matches an alert has caught, newest first — the payoff of an alert. Each match names the watched entity and the podcast episode it was detected on (with episode and podcast slugs that feed particle_podcast_get_episode and particle_podcast_resolve). Use view=detailed to include the transcript excerpts around each mention, and after/before to scope to a date range. Backfilled matches (from the past-week sweep at creation) are flagged and never triggered an email.
Annotations the server declares
- destructiveHint: false
- openWorldHint: false
- readOnlyHint: true
particle_catalogBrowse the full Particle tool catalog.Reads text others write1 finding
Why it is in this group
- The description's first verb is "browse": a word for reading.
What it can reach
- untrusted-inputThe description's first sentence says "browse": it reads web pages, which anyone can write.
Findings
- Info
The description is 3,484 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...ls instead. Discovery is free; tool execution is metered and plan-gated as usual."
Description, as the server wrote it Browse the full Particle tool catalog. Your tools/list shows only the default categories, but EVERY public Particle tool is callable by name regardless of what was advertised — call this tool to discover the rest. Without arguments: the categorical menu (every category with tool names, one-line summaries, and an `↳` line listing each tool's expand options). With `category`: the full input schema for each of that category's tools, ready to call. Two conventions the one-line summaries don't convey, so read tools through this lens: - Tools are lean by default and EXPAND. Most return a minimal payload and opt into richer sections via an `include` array (e.g. a company's people, products, and competitors; a person's roles and podcast appearances) or change behavior via a `mode`/`format` switch. The `↳` line names these — a tool does far more than its summary alone implies. - Responses are a graph; slugs are edges. A slug a tool returns (person, company, podcast, episode, publisher, guest) is a valid input to the other tools, so you resolve once and then traverse: company → its people → a person's podcast appearances → that episode's transcript and every entity in it. Categories on offer: - `system` (always-on): Discovery meta-tools: browse the full tool catalog and call any tool by name. - `podcasts` (default): Resolve podcasts, list and fetch episodes, search transcripts, and find entity mentions. - `people` (default): Resolve people and entities to canonical handles and fetch person profiles. - `companies` (default): Resolve companies and fetch company profiles with people, products, and competitors. - `topics` (default): Browse the hierarchical topic taxonomy used to classify podcast episodes. - `podcast_rankings` (default): Podcast chart rankings: current charts, movers, and ranking history. - `podcast_trends` (default): Trending entities on podcasts: daily entity charts with movement and the quote behind it. - `podcast_guests` (default): Podcast guest directory, trending guests, and per-guest appearance profiles. - `podcast_advertising` (opt-in): Podcast advertising intelligence: sponsor rosters, ad presence, and sponsor leaderboards. - `podcast_publishers` (opt-in): Podcast publisher profiles with their shows, bias profile, and suitability profile. - `podcast_ratings` (opt-in): Listener review ratings for podcasts: summaries and recent rating lists. - `podcast_bias` (opt-in): Corpus-wide political-bias views: publisher leaderboards and publishers by bias result. - `podcast_suitability` (opt-in): Corpus-wide GARM brand-suitability views: publisher leaderboards and category exposure. - `alerts` (default): Create and manage alerts that watch entities for podcast mentions or speaker appearances, preview match frequency, and review the matches an alert has caught. - `reports` (default): Create and manage saved Radar reports that compare one to four people, companies, topics or keywords, each with a link to the report's page on Radar. - `radar` (opt-in): Display selected research results as embedded Radar cards, with a Markdown fallback. Rendering is free and does not fetch data. Opt-in categories can also be advertised on tools/list by adding `?include=<category>` (comma-separated, or `all`) to the connection URL, or the X-Particle-Include header. `?exclude=` hides default categories; `?tools=<name,...>` pins the advertised list to exact tools instead. Discovery is free; tool execution is metered and plan-gated as usual.
Annotations the server declares
- destructiveHint: false
- openWorldHint: false
- readOnlyHint: true
particle_company_getReturn a bundled profile for one company: identifiers (slug, ticker, domain, CIK, QID, linked entity), name, and description.Reads text others writeNo findings
Why it is in this group
- The name "particle_company_get" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Return a bundled profile for one company: identifiers (slug, ticker, domain, CIK, QID, linked entity), name, and description. Request optional sections via `include`: 'people' for current leadership and notable people (person slugs feed `particle_person_get`), 'products' for the three-level product hierarchy, 'competitors' for the competitor list, 'external_links' for the company's LinkedIn, social profiles, domain, Wikidata QID, SEC CIK and tickers. The default response is lean — include only what you need. For sponsor/advertising analytics on this company, use `particle_company_get_podcast_ad_presence` instead.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_company_get_statement_characteristicsHow a company's people speak on podcasts, together, and how that moves over time: the share of their lines that are negative, neutral or positive; hedged, neutral or confident; vag…Reads text others writeNo findings
Why it is in this group
- The name "particle_company_get_statement_characteristics" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it How a company's people speak on podcasts, together, and how that moves over time: the share of their lines that are negative, neutral or positive; hedged, neutral or confident; vague, neutral or specific; and about the past, present or future, overall and per week or month (the last year by default), with how many of the people said them. Use it for 'how confident do OpenAI's people sound lately' or 'are Microsoft's executives talking more about the future'. Pass include=['examples'] for each bucket's strongest line per outer label, with who said it (a person_slug for `particle_person_get_statement_characteristics`), the episode and a link that plays the moment. The people are the ones `particle_company_get` lists with include=['people']: current roles by default, past ones too with include_past_roles. Shares are of their scored lines (lines too short to read carry no characteristics); low_sample marks fewer than 20 behind a share. For one person, use `particle_person_get_statement_characteristics`. Resolve the company first with `particle_company_resolve`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_company_list_peopleList the people at one company, leadership first, a page at a time: the chief executive, then founders, chairs and presidents, the rest of the C-suite, board members, EVPs, SVPs, V…Reads text others writeNo findings
Why it is in this group
- The name "particle_company_list_people" says "list": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it List the people at one company, leadership first, a page at a time: the chief executive, then founders, chairs and presidents, the rest of the C-suite, board members, EVPs, SVPs, VPs, directors, managers, and everyone else, the longest-serving first within a level. Each entry gives the person slug and their title at this company, with the total across all pages. Use it to go past the 25-person preview `particle_company_get` include=people returns, or to narrow a large company with `role` (e.g. executive), `title` (e.g. 'chief', 'investor relations') or `name` (e.g. 'huang'). For one company's profile and its leadership at a glance, call `particle_company_get` instead. To find a person by name, use `particle_person_resolve`. Person slugs feed `particle_person_get`, `particle_person_get_statement_characteristics`, and the `person_slug` filter of `particle_podcast_find_mentions`, `particle_podcast_search_transcripts` and `particle_podcast_list_episodes`. For how the company's people speak on podcasts together, use `particle_company_get_statement_characteristics`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_company_resolveResolve a company by free-text name, ticker, SEC CIK, Wikidata QID, or domain.Reads text others writeNo findings
Why it is in this group
- The name "particle_company_resolve" says "resolve": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Resolve a company by free-text name, ticker, SEC CIK, Wikidata QID, or domain. Returns candidates with the agent-facing identifier (`slug`, falling back to `domain` or `id`) you should pass to `particle_company_get`, `particle_company_get_podcast_ad_presence`, `particle_podcast_find_mentions` (as `company_slug`), or `particle_podcast_list_episodes`. At least one identifier is required. Multiple are ANDed together — useful for disambiguating (e.g. ticker plus a name hint). For people or other knowledge-graph entities (not companies) use `particle_entity_resolve` instead.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_entity_getOne knowledge-graph entity's profile: name, kind, description, and Wikipedia link.Reads text others writeNo findings
Why it is in this group
- The name "particle_entity_get" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it One knowledge-graph entity's profile: name, kind, description, and Wikipedia link. Use it to confirm what a slug from `particle_entity_resolve` actually refers to — especially for the long tail that isn't a person or company (places, organizations, events, products, concepts). When the entity is a linked person or company the response carries the person_slug / company_slug — prefer `particle_person_get` / `particle_company_get` for those, which return the full profiles. Entity slugs feed `particle_podcast_find_mentions`, `particle_podcast_get_episode_timeseries`, and the alert tools.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_entity_resolveResolve any named thing — person, company, place, or other entity — by free-text name in one union search.Reads text others writeNo findings
Why it is in this group
- The name "particle_entity_resolve" says "resolve": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Resolve any named thing — person, company, place, or other entity — by free-text name in one union search. Each candidate carries a `type` and the canonical `slug` for that type: - `person`: the canonical person slug. Feed it into `particle_person_get`, every `person_slug` parameter (`particle_podcast_find_mentions`, `particle_podcast_search_transcripts`, `particle_podcast_list_episodes`), or `particle_podcast_get_guest`'s `guest_slug`. - `company`: the canonical company slug. Feed it into `particle_company_get` and every `company_slug` parameter. - `place`/`other`: a bare entity slug. Feed it into the `entity_slug` parameter on `particle_podcast_find_mentions`, `particle_podcast_search_transcripts`, and `particle_podcast_list_episodes` to filter by that entity. Use this first whenever you only have a name and don't know what kind of thing it names. If you already know it's a person, `particle_person_resolve` ranks people only; for companies with a known ticker, domain, CIK, or QID, `particle_company_resolve` has more identifier surface. For bulk resolution, pass a comma-separated `query` (e.g. "sam altman, nvidia, davos") — each name is resolved independently in a single call and `limit` applies per query.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_expertise_getDescribe one occupation or field of research and, on request, who is booked under it: its parent, children and crosswalk by default; `include: ["top_guests"]` ranks the guests list…Reads text others writeNo findings
Why it is in this group
- The name "particle_expertise_get" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Describe one occupation or field of research and, on request, who is booked under it: its parent, children and crosswalk by default; `include: ["top_guests"]` ranks the guests listed under it by podcast appearances in a window (default the last 30 days, at most 90), and `include: ["top_podcasts"]` ranks the shows that booked them. `standing="established"` ranks only credentialed or recognized experts — "the shows that book established finance experts" is `field` plus top_podcasts plus standing. A broad code covers everything below it. Take codes from `particle_expertise_resolve`, which turns free text ("doctors", "finance") into them; on `unresolved_reference` or `not_found`, resolve and retry. Guest slugs work with `particle_person_get` (`include: ["expertise"]`) and `particle_podcast_get_guest`; podcast slugs with every podcast tool. For a multi-criteria guest search (practicing, seniority, capacity, employer, all-time) use `particle_podcast_list_guests`; for one show's guest mix use `particle_podcast_resolve` with `include: ["guest_expertise"]`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_expertise_resolveTurn free text into the occupation and field-of-research codes the speaker-expertise filters take.Reads text others write1 finding
Why it is in this group
- The name "particle_expertise_resolve" says "resolve": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Info
The description mentions "credentials".
What this check looks forMatched text
description: "...is speaking by occupation, profession, credentials or industry ("doctors", "medical profes..."
Description, as the server wrote it Turn free text into the occupation and field-of-research codes the speaker-expertise filters take. When a question restricts who is speaking by occupation, profession, credentials or industry ("doctors", "medical professionals", "economists", "people in finance", "lawyers"), the filters, not search wording, decide who speaks. `guest_occupation` takes the everyday word itself, so the first search can carry it without waiting for this tool: call it to see or choose among the codes, and when a filter returns `unresolved_reference`, then retry with the code. Codes are SOC 2018 occupations (with their ISCO-08 equivalents) and ANZSRC 2020 fields of research. 'cardiologist' finds SOC 29-1212 Cardiologists; 'finance' finds the finance fields. Each code comes back with its slug, level, parent and the parameters that accept it: `occupation`/`field` on `particle_podcast_list_guests` and `particle_expertise_get`, and `guest_occupation`/`guest_field` on `particle_podcast_find_mentions`, `particle_podcast_list_episodes`, `particle_podcast_search_transcripts`, `particle_podcast_get_episode_timeseries` and `particle_podcast_resolve`. Pass `parent` to walk the hierarchy one level down (a SOC major group's minor groups, then broad groups, then occupations; a division's groups); a group such as `physicians` or an everyday name such as `doctors` filters everything below it. A word no occupation names may name a field (`oncologists` finds field 3211 Oncology) or a capacity: `founders` comes back as the capacity `executive_founder`, which `capacity` on `particle_podcast_list_guests` and `guest_capacity` on the episode and mention tools take. Not for people or companies — use `particle_person_resolve`, `particle_company_resolve` or `particle_entity_resolve`. Not the topic taxonomy either: `particle_topic_browse` classifies what episodes are about, these codes classify what speakers know.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_person_getReturn a person's profile: name, current role, and bio, keyed by the canonical person slug from `particle_person_resolve`.Reads text others write1 finding
Why it is in this group
- The name "particle_person_get" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Info
The input schema at properties.include.description mentions "credential".
What this check looks forMatched text
inputSchema.properties.include.description: "...he guest_ filters accept, organization, credential). Default response is lean — request on..."
Description, as the server wrote it Return a person's profile: name, current role, and bio, keyed by the canonical person slug from `particle_person_resolve`. Request optional sections via `include`: 'external_links' for LinkedIn/Wikipedia/social profiles, 'podcast_appearances' for their most recent podcast appearances (episode and podcast slugs included for follow-up calls), 'companies' for the full role history, 'sports' for an athlete's or coach's current team (NFL, MLB and NHL rosters), sports, teams (with years and leagues) and leagues, with entity slugs for `particle_entity_get` (only the current team says where a player is today: a team with no end year may be one they left), 'expertise' for what they know and how established they are (standing, seniority, the occupations and fields they are listed under — codes that `guest_occupation`/`guest_field` and `particle_expertise_get` accept). The default response is lean. For podcast-guest analytics (appearance stats, suitability exposure, co-appearance graph) use `particle_podcast_get_guest` with the same slug.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_person_get_statement_characteristicsHow a person speaks on podcasts, and how that moves over time: the share of their lines that are negative, neutral or positive; hedged, neutral or confident; vague, neutral or spec…Reads text others writeNo findings
Why it is in this group
- The name "particle_person_get_statement_characteristics" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it How a person speaks on podcasts, and how that moves over time: the share of their lines that are negative, neutral or positive; hedged, neutral or confident; vague, neutral or specific; and about the past, present or future, overall and per week or month (the last year by default). Use it for 'is Sam Altman more cautious than he used to be', 'how often does she make predictions', or 'how positive has he been lately'. Pass include=['examples'] for each bucket's strongest line per outer label, with episode slugs for `particle_podcast_get_episode` and a link that plays the moment. Shares are of the person's scored lines (lines too short to read carry no characteristics); low_sample marks fewer than 20 behind a share. To find their lines said a certain way about a topic, use `particle_podcast_search_transcripts` with person_slug and speaker_statement_characteristics. Resolve the person first with `particle_person_resolve`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_person_resolveResolve a person by free-text name.Reads text others writeNo findings
Why it is in this group
- The name "particle_person_resolve" says "resolve": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Resolve a person by free-text name. Returns ranked candidates with the canonical person `slug` — the stable handle accepted by `particle_person_get`, by every `person_slug` parameter (`particle_podcast_find_mentions`, `particle_podcast_search_transcripts`, `particle_podcast_list_episodes`), and by `particle_podcast_get_guest`'s `guest_slug`. For bulk resolution, pass a comma-separated `query` — each name resolves independently in one call. For organizations, places, or mixed/unknown entity kinds use `particle_entity_resolve`; for companies with a known ticker or domain use `particle_company_resolve`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_find_mentionsFind dialogue lines where a specific person or company is named in podcast transcripts.Reads text others write1 finding
Why it is in this group
- The name "particle_podcast_find_mentions" says "find": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe name "particle_podcast_find_mentions" says "find" and "mention": it reads comments, which other people can write.
Findings
- Info
The description is 6,226 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...s the filter with `sort: "strength"` on `particle_podcast_find_mentions` instead."
Description, as the server wrote it Find dialogue lines where a specific person or company is named in podcast transcripts. ## Three response modes **`format="summary"` (default, wide scan).** Returns up to `limit` episodes (reverse-chronological), each with metadata + the first 10 mention-only lines (just the lines naming the entity, no surrounding dialogue). Use this to see *what's been said across episodes* and decide which episodes are worth reading in full. Paginate older episodes with `cursor`. **`format="detail"` (narrow drill-in).** Requires `episode_slug`. Returns the full mention windows with `context_lines` of surrounding dialogue around each mention. Pass one slug for a single episode, or up to 10 comma-separated slugs (e.g. `episode_slug="all-in-200,all-in-201,all-in-202"`) to multi-get several episodes in one call. `limit`/`cursor` don't apply. **`format="compact"` (screening).** The same episodes as summary, each with its mention count, the strings it was mentioned as, and the segments carrying the mentions (id, title, type, first mention time) — no dialogue lines at all, the smallest shape. `limit` and `cursor` page it exactly as summary. Use it to fan out over many entities or a long date range and decide where to read; the segment ids are citations, and `format="detail"` with the episode slug reads the lines. ## Workflow Two patterns, depending on what you already know: - **No specific episode in mind:** call `format="summary"` first to scan, then call `format="detail"` with the slug(s) of the episodes worth reading in full. For most questions (sentiment, recurring themes, who said what when), summary alone has enough signal and the second call isn't needed. - **Already have the episode slug** (e.g. user mentioned the episode by name, or you have it from another tool like `particle_podcast_get_episode` or `particle_podcast_search_transcripts`): skip summary entirely and call `format="detail"` with `episode_slug` directly. ## Examples *Wide scan, then drill in:* User asks "what has All-In said about OpenAI recently?". Call `format="summary"`, `company_slug="openai"`, `podcast_slug="all-in"`, `since="2025-11-01"`, `limit=20`. Read the mention lines per episode; if 2-3 episodes have substantive discussion, call `format="detail"`, `episode_slug="slug1,slug2,slug3"` for full context in one round-trip. *Direct drill-in:* User says "In All-In #200 they discuss OpenAI's strategy — pull the full quotes". Call `format="detail"`, `episode_slug="all-in-200"`, `company_slug="openai"` directly — no summary needed. ## Who said it The `guest_` filters keep only the mentions a matching guest spoke: `guest_field="banking-finance-and-investment"` with `guest_standing="established"` reads what established finance experts said about a company. When the question names who speaks ("doctors", "economists", "people in finance"), resolve the words with `particle_expertise_resolve` first and filter by the code; on `unresolved_reference`, resolve and retry rather than dropping the filter. A word no occupation names may name a capacity instead ("founders", "politicians"): pass it as `guest_capacity`. Each episode lists its identified speakers with their occupation codes, standing and seniority. For the split of all mentions across occupations or fields use `particle_podcast_get_share_of_voice`. ## When NOT to use this tool For dialogue that *discusses* a topic without naming a specific person or company (paraphrase-tolerant search), use `particle_podcast_search_transcripts` instead — that one ranks segments by relevance to a free-text query. For how often the subject comes up, or which shows mentioned it this week versus last, use `particle_podcast_get_mention_trends` instead of paging this tool once per period; its podcast slugs come back here as `podcast_slug` to read what a show said. ## Strongest first With `speaker_statement_characteristics`, `sort="strength"` puts the episodes whose mentions carry the labels most clearly first: the most clearly negative takes on a company, the most confident predictions about a drug. This is the tool for the strongest lines about a subject; `particle_podcast_search_transcripts` refuses a subject without a topic and sends you here. ## Required inputs One of `person_slug`, `company_slug`, or `entity_slug` is required: `person_slug` for a person, `company_slug` for a company, `entity_slug` for any other knowledge-graph entity (places, organizations, events, concepts). Resolve a name to a slug first with `particle_person_resolve`, `particle_company_resolve`, or `particle_entity_resolve`. Slugs are case-insensitive on input. **How each line is said.** Lines in topic and interview segments end with their speaker statement characteristics, pole labels only, e.g. `_[positive · confident · future]_`: sentiment (negative/positive), certainty (hedged/confident), specificity (vague/specific) and temporal orientation (past/future). A pole label means the line clearly reads that way; `_[neutral]_` means it leans clearly on no axis; no brackets means the line was not read (short lines, intros, ad breaks). With `output_format=json` they are each line's `speaker_statement_characteristics` object, middle labels included. **Filtering by how a line is said.** Pass `speaker_statement_characteristics` to keep only lines said a certain way: `{"sentiment": ["negative"]}` for criticism, `{"specificity": ["specific"], "temporal_orientation": ["future"]}` for concrete predictions, `{"certainty": ["confident"], "sentiment": ["positive"], "temporal_orientation": ["future"]}` for a high-conviction outlook. Put the topic, never the tone, in `semantic_search`. Every matched or mention line then carries labels the filter accepts. **Without a topic.** On `particle_podcast_search_transcripts`, the filter alone with `episode_slug`, `speaker` or a `guest_` filter (no `semantic_search` or `keyword_search`) returns the strongest lines said that way, at most 50, strongest first: an episode's boldest predictions… [226 more characters not shown]
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_get_entity_chartWhat is trending on podcasts: Particle's daily Trends charts, which rank the entities (people, shows, films, games, books, brands, athletes, teams) that the most podcasts are talki…Reads text others writeNo findings
Why it is in this group
- The name "particle_podcast_get_entity_chart" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it What is trending on podcasts: Particle's daily Trends charts, which rank the entities (people, shows, films, games, books, brands, athletes, teams) that the most podcasts are talking about, with each entry's movement since the previous edition and, when the editors explained it, why it moved, backed by a verbatim podcast quote and a link that plays it. Call with no arguments for the cross-category `all` chart. Pick a narrower chart with `chart` (its schema lists every chart and the windows it publishes): entertainment (`tv-series`, `movies`, `video-games`), sports leagues (`nfl`, `nba`, ...), books (`fiction`, `nonfiction`, `comics-manga`), and `guests`, which ranks people by the distinct shows they appeared on. `sort=acceleration` surfaces the fastest risers anywhere in the chart. Rank does not follow the podcast count: every chart except `guests` ranks by how far an entry's coverage sits above its own normal level, so a lower count can rank higher. Each entry returns a slug. Pass an entity slug to `particle_entity_get`, or to `particle_podcast_get_mention_trends` (`entity_slug`) for which podcasts drive it; pass a person slug to `particle_person_get` or `particle_podcast_get_guest`; pass a quote's episode id to `particle_podcast_get_episode`. Not for podcast shows' own chart positions on Apple or Spotify: use `particle_podcast_get_rankings`. Not for one subject you already know: use `particle_podcast_get_mention_trends`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_get_episodeReturn a bundled overview of one podcast episode: title, podcast, speakers (with entity slugs), top mentioned entities, and segment/clip counts.Reads text others writeNo findings
Why it is in this group
- The name "particle_podcast_get_episode" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Return a bundled overview of one podcast episode: title, podcast, speakers (with entity slugs), top mentioned entities, and segment/clip counts. By default the response is lean — counts plus the top mentioned entities. Request optional sections via `include`: 'segments' for the structural outline with timestamps, 'entities' for the complete entity list, 'clips' for engagement-ranked highlight clips, 'topics' for topic classifications with slugs, 'guest_expertise' for each guest's expertise and whether they spoke within their field, 'speaker_statement_characteristics' for how the episode's lines were said (label shares overall and per speaker, who is most hedged or forward-looking, and a few of its strongest predictions, confident claims, criticism and optimism lines), or 'transcript' for the dialogue transcript (narrow it by speaker or time range via `transcript_speaker` / `transcript_start` / `transcript_end` — full transcripts are large). For "every line about X in this episode" use `particle_podcast_find_mentions` with `episode_slug` instead — that returns the dialogue around each mention with `is_mention` flags. For the ad reads inside the episode use `particle_podcast_get_episode_ads` (premium).
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_get_episode_timeseriesTime-bucketed episode counts — the purpose-built answer to "how often is X discussed over time".Reads text others writeNo findings
Why it is in this group
- The name "particle_podcast_get_episode_timeseries" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Time-bucketed episode counts — the purpose-built answer to "how often is X discussed over time". Counts episodes matching the same filters as `particle_podcast_list_episodes` (person, company, entity, podcast, keyword, language, duration, transcript availability) per day, week, or month, plus range totals. `keyword_search` additionally counts matching transcript segments per bucket (exact counts); `semantic_search` does the same by meaning, with the same similarity threshold as `particle_podcast_search_transcripts` (lower bounds for pathologically broad queries), and requires `published_after`. The two cannot be combined. Use this for appearance, publication, or topic trend lines instead of paging `particle_podcast_list_episodes`, `particle_podcast_find_mentions`, or `particle_podcast_search_transcripts` once per period. For how often a person, company or brand is mentioned, use `particle_podcast_get_mention_trends`: it leaves ad reads out, where this tool counts an episode for a company or entity named only in its ad reads, and it says which podcasts carried the mentions. Buckets are UTC-aligned, zero-filled, and Monday-aligned for weeks; ranges are capped at 1000 buckets. At least one of podcast_slug, person_slug, company_slug, entity_slug, keyword_search, semantic_search, guest_occupation, or guest_field is required. The `guest_` filters count episodes by their guests' expertise (resolve the words to codes with `particle_expertise_resolve` first; on `unresolved_reference`, resolve and retry): `guest_field` alone charts how often a field's experts are booked; with `company_slug` it charts the company's episodes featuring those experts. They are episode-level and never check who spoke: with `keyword_search`, a matching segment counts when its episode had such a guest, even if the host said the words. For who said a keyword, use `particle_podcast_get_share_of_voice` with `keyword_search`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_get_guestA guest's podcast-appearance profile: lifetime stats (appearances, distinct podcasts, first/last appearance) plus their most frequent podcasts.Reads text others writeNo findings
Why it is in this group
- The name "particle_podcast_get_guest" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it A guest's podcast-appearance profile: lifetime stats (appearances, distinct podcasts, first/last appearance) plus their most frequent podcasts. Guests are people — the same slug works with `particle_person_get` for the biographical profile. Request optional sections via `include`: 'appearances' for the most recent episode appearances (episode and podcast slugs included for follow-up calls), 'podcasts' for the per-podcast rollup, 'suitability' for brand-suitability exposure across the podcasts they appear on, 'recommended_podcasts' for the five shows they could plausibly appear on next — shows related to the ones they have guested on, with the venues behind each pick and each show's suitability tier, latest episode and chart breadth (the pitch list; branch on each row's band). It already leaves out every show they have appeared on, other feeds of those shows with the same host, shows that stopped publishing and UNSAFE shows, and ranks shows far smaller than their usual venues lower, so there is no need to check each pick's episodes, 'in_field_appearances' for the most recent appearances where they spoke within their own field of expertise (what they know is what the episode drew on; `particle_person_get` with `include: ["expertise"]` says what that field is). Returns not_found for people who exist but have never appeared on a podcast — use `particle_person_get` for those.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_get_mention_trendsHow a person's, company's or entity's podcast mentions are moving, for tracking it week over week.Reads text others write1 finding
Why it is in this group
- The name "particle_podcast_get_mention_trends" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe name "particle_podcast_get_mention_trends" says "get" and "mention": it reads comments, which other people can write.
- untrusted-inputThe description's first sentence says "mention": it reads comments, which other people can write.
Findings
- Info
The description is 3,056 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...old about new mentions as they air, create an alert with `particle_alert_create`."
Description, as the server wrote it How a person's, company's or entity's podcast mentions are moving, for tracking it week over week. To find what is rising across all podcasts rather than track a subject you already know, use `particle_podcast_get_entity_chart`. Two modes: - `compare` (default): which podcasts mentioned it in a window (default the last 7 days, at most 90) and how each compares with the equal-length window before it: episode and mention line counts in both, the delta, and a label. A show in both windows is `continuing`; one only in the previous is `dropped`. A show only in the current window is judged against the lookback before it (`lookback_days`, default 90): `new` when it never mentioned the subject there, published at least four episodes there, and has two or more mention lines now; `returning` when it mentioned the subject earlier in the lookback; `passing` for a single line; `newly_tracked` when it published too little in the lookback to tell. Totals for both windows count every podcast. Filter with `change`, order with `sort` (`rising` and `falling` for the biggest movers), and page with `cursor`. Answers "which shows talked about Nike this week versus last?" in one call, and, with `change="new"` (sorted by popularity unless `sort` is set), "which podcasts started talking about Nike this month?" or "which mentioned Nike for the first time?": read what the leading shows said with `particle_podcast_find_mentions`. Since 2026-10-23, `new` no longer means every show absent from the previous window; that set is now `new`, `returning`, `passing` and `newly_tracked` together. - `timeseries`: mention counts per day, week or month over a range (omit `published_after` for all time), each bucket with its episodes, mention lines and distinct podcasts. Answers "is it rising?". `podcast_slug` charts one show. `breakdown` splits each bucket by a speaker statement characteristics label (`breakdown="sentiment"`: is it spoken of more negatively this quarter?), and `speaker_statement_characteristics` counts only the mentions said that way (`{"temporal_orientation": ["future"]}`: are predictions about it rising?); both need `published_after`, at most 365 days back. Mentions inside ad reads are left out unless `include_ads`, so a brand that advertises heavily is measured by what shows say about it. The newest day fills in over about a day as episodes are processed, so a window ending now reads slightly low and the current bucket is marked partial: compare full buckets. Podcast slugs in the response work with `particle_podcast_find_mentions` (with the same dates as `since` and `until`, to read what a show said) and `particle_podcast_list_episodes`. Not for the mention lines themselves (`particle_podcast_find_mentions`), appearance or topic trends by role or keyword (`particle_podcast_get_episode_timeseries`, which counts an episode for a company named only in its ad reads), or a split by who said it (`particle_podcast_get_share_of_voice`). To be told about new mentions as they air, create an alert with `particle_alert_create`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_get_rankingsPodcast chart rankings from Apple Podcasts and Spotify, in four modes: - `chart` (default): the current chart for a source/country/category slot, or — with `podcast_slug` — every c…Reads text others writeNo findings
Why it is in this group
- The name "particle_podcast_get_rankings" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Podcast chart rankings from Apple Podcasts and Spotify, in four modes: - `chart` (default): the current chart for a source/country/category slot, or — with `podcast_slug` — every chart slot that podcast currently holds. - `movers`: the biggest rank changes over `window_days` (risers, fallers, entries, exits). Most `change=new` entries are established shows returning to the chart; for new podcasts, launches, or debuts use `change=debut` — shows on that chart slot for the first time since tracking began (May 2026). A debut is per slot: a show can debut on the overall chart after months in a category, so read its episode count and, when shown, its first-episode date before calling it brand-new. - `history`: past snapshots for a chart slot, or — with `podcast_slug` — one podcast's chart history over time, newest first. Per-podcast history defaults to `country=us`; pass `country` for other markets. For one chart's trajectory pass `source`, `country`, and `category_slug` too (omit `category_slug` for the overall chart plus every category): 90 days of one slot fits in one page of 100, where the unfiltered history of a popular show runs to hundreds of rows. History begins in May 2026. - `slots`: the valid slot values — every source, country, and category_slug with live chart data — so filter values are discovered, not guessed. `source` narrows the country/category listings; other filters are ignored. Each row carries the matched `podcast_slug` when the chart entry is in the catalog — feed it into `particle_podcast_resolve` or any podcast tool. For a single podcast's at-a-glance chart presence, `particle_podcast_resolve` with `include: ["rankings"]` is one call instead of two.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_get_transcription_requestRead where your organization's transcription request stands, by request_id or by the episode's episode_slug.Reads text others writeNo findings
Why it is in this group
- The name "particle_podcast_get_transcription_request" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Read where your organization's transcription request stands, by request_id or by the episode's episode_slug. Free: this is how to wait for a transcription that particle_podcast_request_transcription queued, so poll it every minute or so (a transcription usually takes 5 to 10 minutes) rather than requesting again. state is queued (waiting its turn), admitted (being transcribed), transcribed (the episode tools now serve its transcript: particle_podcast_get_episode, particle_podcast_find_mentions, particle_podcast_search_transcripts), or failed (failure_reason says why, and the charge is refunded). By episode_slug, your organization's request answers even once the episode is transcribed; for an episode we hold that it never requested, there is no request, and state says where its transcript stands.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_list_clipsBrowse AI-extracted highlight clips across the catalog, ranked by engagement potential — the shareable moments.Reads text others writeNo findings
Why it is in this group
- The name "particle_podcast_list_clips" says "list": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe description's first sentence says "browse": it reads web pages, which anyone can write.
Description, as the server wrote it Browse AI-extracted highlight clips across the catalog, ranked by engagement potential — the shareable moments. Filter by podcast, episode, clip type (FUNNY, CONTROVERSIAL, INSIGHTFUL, ...), minimum engagement score, or speaker — `speaker` takes a person slug and returns only clips of that person talking ('an insightful Sam Altman clip'). Pass `clip_id` for one clip's full detail (description, social-hook intro, speaker, audio URL), plus `include: ["transcript"]` for its dialogue. For text-based clip discovery — finding clips about a topic or entity — use `particle_podcast_search_transcripts` instead: matching clips arrive inline on each search result. Episode slugs on every row feed `particle_podcast_get_episode`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_list_episodesList episodes across the catalog with rich filters: by podcast, person, company, language, date range, duration, or transcript availability.Reads text others writeNo findings
Why it is in this group
- The name "particle_podcast_list_episodes" says "list": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it List episodes across the catalog with rich filters: by podcast, person, company, language, date range, duration, or transcript availability. By default it lists the episodes we have ingested. Pass `transcript_status` with `podcast_slug` to reach the show's back catalogue — older episodes discovered in its feed but not transcribed, marked requestable. Their transcript, segments, speakers and entities do not exist until one is requested. Use this for episode-level discovery when you only need metadata (title, duration, speakers, counts). For dialogue around a person in any episode, use `particle_podcast_find_mentions`. For ranked retrieval by topic, use `particle_podcast_search_transcripts`. The `guest_` filters list episodes by their guests' expertise (resolve the words to codes with `particle_expertise_resolve` first; on `unresolved_reference`, resolve and retry): `guest_occupation="cardiologists"` with `guest_practicing=true` lists episodes with a practicing cardiologist as a guest, and `guest_capacity="executive_founder"` lists episodes with a founder as a guest.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_list_guestsBrowse podcast guests across the catalog, in two opinionated modes: - `directory` (default): the guest directory ranked by lifetime appearances (guests with 2+ appearances).Reads text others write1 finding
Why it is in this group
- The name "particle_podcast_list_guests" says "list": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe description's first sentence says "browse": it reads web pages, which anyone can write.
Findings
- Info
The input schema at properties.standing.description mentions "credential".
What this check looks forMatched text
inputSchema.properties.standing.description: "...: 'established' (conferred by others: a credential, a position, recognition in the field),..."
Description, as the server wrote it Browse podcast guests across the catalog, in two opinionated modes: - `directory` (default): the guest directory ranked by lifetime appearances (guests with 2+ appearances). - `trends`: who's making the rounds right now — guests with appearances on 2+ distinct podcasts in the last 30 days, which surfaces cross-show press tours rather than show regulars. The press-tour shape is enforced: every in-window appearance must be on a different podcast, each needs 5+ minutes of identified speaking time, mononymous catch-all people are excluded, and the in-window rate must be a 2x spike over the guest's lifetime baseline. For the daily ranked guests chart, with movement since the previous edition and each guest's top clip, use `particle_podcast_get_entity_chart` with `chart="guests"`. `podcast_slug` switches the directory to one show's roster: every guest who has appeared on that podcast, ranked by appearances on the show (one-off guests included). `topic_slug` narrows either corpus mode to guests appearing on episodes about that topic. `occupation`/`field` (with `standing`, `seniority`, `practicing`, `capacity`, `employer`) keep guests by what they know: resolve the words ("doctors", "economists") to codes with `particle_expertise_resolve` first, and on `unresolved_reference` resolve and retry rather than dropping the filter. Every row names the guest's occupation codes, standing and seniority; `include: ["expertise"]` adds their organization. Guest slugs ARE person slugs — feed them into `particle_podcast_get_guest` for the appearance profile or `particle_person_get` for the person profile.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_resolveFind a podcast by free-text title, exact slug, iTunes ID, or RSS feed URL.Reads text others write1 finding
Why it is in this group
- The name "particle_podcast_resolve" says "resolve": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe description's first sentence says "find" and "rss": it reads web pages, which anyone can write.
Findings
- Info
The description is 3,194 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...n a recent window, use `particle_expertise_get` with `include: ["top_podcasts"]`."
Description, as the server wrote it Find a podcast by free-text title, exact slug, iTunes ID, or RSS feed URL. Returns slug, title, episode count, bias, and the top recurring speakers (with entity slugs). Use the slug as the agent-facing handle to feed into other podcast tools (`particle_podcast_find_mentions`, `particle_podcast_list_episodes`, `particle_podcast_get_sponsors`). Free-text matching is forgiving — typos, missing or extra words, and pasted episode titles all work. Results are ordered best-match-first; text matches carry a `match_quality` field, and an empty list means the catalog has no plausible candidate. With all identifiers omitted, returns the most recently updated podcasts — useful for browsing the catalog when you don't have a name in mind. Narrow free-text browsing with `topic_slug` (topic concentration, descendants included), `suitability_tier`, or `min_popularity` (global popularity percentile over charting podcasts). Optional hydrations attach extra data to each result in the same call: - `include: ["external_links"]`: third-party platform presences (directories, social profiles, video channels, publisher websites) with resolved URLs and audience metrics. - `include: ["suitability"]`: per-category brand-suitability breakdown (12 categories with prevalence, treatment, derived risk level, reasoning, and evidence excerpts) — premium-grade data, requires a plan with premium endpoints. The high-level `suitability_tier` enum (SAFE / LIMITED / SENSITIVE / UNSAFE) is rendered on every result without opt-in. - `include: ["ratings_summary"]`: listener-review aggregate (average stars, count, per-platform breakdown). - `include: ["bias"]`: full political-bias analysis (the high-level bias enum is always rendered without opt-in). - `include: ["rankings"]`: current chart positions across sources/countries/categories — premium-grade data, requires a plan with premium endpoints. For movers and history use `particle_podcast_get_rankings`. - `include: ["format"]`: the show's format profile — how often episodes feature guests, detected production formats (interview, panel, call_in, solo_narrated), ad and video presence, episode-length distribution, publishing cadence, and the publish-day pattern. - `include: ["guest_expertise"]`: the show's guest mix — shares of its analyzed guest appearances by established, senior and in-field guests and promotional appearances, and the occupations and fields it books most. - `recent_episodes: N`: inline this many of each result's most recent episodes (slug, title, published_at, duration) — skip the follow-up `particle_podcast_list_episodes` call when you only need the most recent tail. Find shows by who they book with `guest_occupation` or `guest_field` (resolve the words to codes with `particle_expertise_resolve` first) and the share floors `min_established_guest_share`, `min_in_field_guest_share` and `max_promotional_guest_share`: `guest_field="banking-finance-and-investment"` with `min_established_guest_share=0.5` finds shows that book established finance experts. For the shows that booked an occupation's or field's guests most in a recent window, use `particle_expertise_get` with `include: ["top_podcasts"]`.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_podcast_search_transcriptsSearch the podcast catalog by what is said in episodes — by meaning (`semantic_search`), by exact phrase (`keyword_search`), or both at once (hybrid ranking).Reads text others write2 findings
Why it is in this group
- The name "particle_podcast_search_transcripts" says "search": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Info
The description mentions "credentials".
What this check looks forMatched text
description: "...ished"` or `guest_practicing=true` when credentials matter); never stand the profession in..."
- Info
The description is 7,016 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...s the filter with `sort: "strength"` on `particle_podcast_find_mentions` instead."
Description, as the server wrote it Search the podcast catalog by what is said in episodes — by meaning (`semantic_search`), by exact phrase (`keyword_search`), or both at once (hybrid ranking). This is THE way to retrieve relevant dialogue, segments, and clips: each result is one segment of one episode with bounded transcript windows pinpointing the highest-relevance lines, plus any highlight clips that overlap the segment inline on the match. Segments partition an episode's transcript — where start_line and end_line are present, every spoken line belongs to exactly one segment and one segment's end_line + 1 is the next one's start_line. They are contiguous in transcript lines, not in wall-clock seconds: the seconds between one segment's end_seconds and the next's start_seconds contain no transcribed speech. These matches do not carry the line ranges themselves — fetch them with `particle_podcast_get_episode` and `include: ["segments"]`, where their absence marks an episode segmented by an earlier version, a small share of which do leave lines uncovered. Clips are sparse, engagement-ranked highlights that overlap some segments. There is no separate clip-search tool — relevant clips arrive on these matches, and a known episode's full clip list is `particle_podcast_get_episode` with `include: ["clips"]`. A match window defaults to one line of context around each matched line; raise `context` to widen windows in place instead of fetching the full transcript. **Screening many results?** Pass `format: "compact"`. Each match then carries only its identity — episode and podcast slugs, segment id and bounds, segment type, the segment's one-line description, and the relevance score — with no dialogue or clips, at a fraction of the size and latency of the default. Fan out compact searches over companies, themes, or dates, decide which segments matter, then read dialogue only for those: `particle_podcast_get_episode` with `include: ["transcript"]` and `transcript_start`/`transcript_end` set to the segment's bounds, or this tool again with `episode_slug` narrowed to that episode. Use this for "find dialogue *about* a topic". For "every line *naming* a person or company" use `particle_podcast_find_mentions` instead — `person_slug` and `company_slug` here narrow ranked results, they don't drive the ranking. **Choosing your query.** At least one of `semantic_search` or `keyword_search` is required, and they do different jobs: - `semantic_search` carries the *idea*. Write it as a sentence describing what should be discussed, in the vocabulary a speaker would use. It is paraphrase-tolerant, so it finds the topic however it happens to be worded. - `keyword_search` carries words that must be *literally spoken*. Every word must occur in the same passage, so it is for one or two exact tokens — a ticker, a product name — not for a description. Putting a sentence here returns nothing. - Use both when a topic must also contain an exact term. The result is their intersection, which is narrow by design; if that comes back empty, `keyword_match: "ranked"` relaxes the keyword side to a relevance hint. **Do not put a name in `semantic_search`.** Resolve it (`particle_person_resolve`, `particle_company_resolve`, `particle_entity_resolve`) and pass the slug — searching for "Sam Altman" as text finds passages that *sound like* him, while `person_slug` finds the episodes actually featuring him. **The question's constraints go on the first call.** Who is speaking, which person, company or show, which window or language: when the question states it, pass it from the start, because a search without it answers a different question. Hold back only the filters you add on your own (a `segment_type`, a `role`, a narrower window) until a search shows the topic has coverage: every filter compounds, and each one can remove all results. If a search returns nothing because of a filter, the error names the parameter responsible and the retry to make — act on it rather than re-issuing variations of the same query, and when a constraint the question stated is what emptied it, say so before showing anything wider. **Note on `role`.** It describes how someone relates to the episode: `guest`/`host`/`panelist`/`correspondent` mean they *spoke*, `mention` means they were *talked about*. Omitting `role` covers both and is almost always what you want. **Who is speaking.** When the question restricts who speaks by occupation, profession or industry ("medical professionals", "economists", "lawyers"), pass the words themselves as `guest_occupation`, which resolves an everyday word to the occupation, field or capacity it names, or a code from `particle_expertise_resolve` as `guest_occupation`/`guest_field` (plus `guest_standing="established"` or `guest_practicing=true` when credentials matter); never stand the profession in for a filter inside `semantic_search`. On `unresolved_reference`, resolve and retry; never drop the filter. A word no occupation names may name a capacity ("founders", "politicians"): pass it as `guest_capacity`. The filters AND together, so two groups ("founders and VCs") take one call each. The filters keep segments in which such a guest speaks, so a window can also carry the host's lines: each full-format match lists its identified speakers as `**Speaker:**` rows with their occupation codes, standing and seniority — check them before attributing a line to a credential. **How each line is said.** Lines in topic and interview segments end with their speaker statement characteristics, pole labels only, e.g. `_[positive · confident · future]_`: sentiment (negative/positive), certainty (hedged/confident), specificity (vague/specific) and temporal orientation (past/future). A pole label means the line clearly reads that way; `_[neutral]_` means it leans clearly on no axis; no brackets means the line was not read (short lines, intros, ad breaks). With `output_format=json` they are each line's `speaker_statement_characteristics` object, middle labels inclu… [1016 more characters not shown]
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_report_getGet one saved Radar report: its name, subjects, period, sources and presentation settings, and its Radar link.Reads text others writeNo findings
Why it is in this group
- The name "particle_report_get" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Get one saved Radar report: its name, subjects, period, sources and presentation settings, and its Radar link. The report's mentions and news are read on its Radar page, not returned here; to answer from the data, use the podcast tools on the same subjects.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
particle_report_listList the saved Radar reports in your project, most recently edited first, each with its id, subjects and Radar link.Reads text others writeNo findings
Why it is in this group
- The name "particle_report_list" says "list": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it List the saved Radar reports in your project, most recently edited first, each with its id, subjects and Radar link. Feed an id into particle_report_get for its full settings, particle_report_update to change it, or particle_report_delete. Check here before creating a report the project may already have.
Annotations the server declares
- destructiveHint: false
- openWorldHint: true
- readOnlyHint: true
This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.
Exfil surface
Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.
40 paths in this server alone from private data, through text someone else wrote, to a way out. Denying 1 outbound tool breaks every one.
- Reads private data1
- Reads files, mail, messages, databases, secrets, calendars or repositories.
- Reads text others write40
- Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
- Can send data out1
- Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.
{
"permissions": {
"deny": [
"mcp__particle-pro__particle_report_create"
]
}
}Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.
Remote posture
What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.
Looked at Nov 20, 2026, 19:17 UTC, unchanged since Nov 20, 2026. No credentials were sent and no tool was called. What is looked at.
- Reachable
- yes
- HTTP status of an anonymous initialize
- 200
- tools/list served without credentials
- yes
- Tools that change things, listed without credentials
- 10
- Protocol version
- 2025-06-18
- WWW-Authenticate on 401
- not observed
- resource_metadata in WWW-Authenticate
- not observed
- RFC 9728 protected resource metadata
- https://mcp.particle.pro/.well-known/oauth-protected-resource
- Authorization servers
- https://api.particle.pro
- Legacy HTTP+SSE transport
- no
- Dynamic client registration
- yes
- Client ID metadata documents
- yes
- HighThe whole server
The endpoint served tools/list without credentials, and the list has 10 tools that change things (6 destructive, 1 irreversible, 3 write). Whether a call also works without credentials was not tested: tools are never called.
What this check looks forMatched text
https://mcp.particle.pro: tools/list returned 44 tools to an anonymous client, including particle_alert_create (destructive), particle_alert_delete (destructive), particle_alert_update (destructive), particle_call (destructive), particle_report_delete (destructive) and 5 more
Posture changes
- Nov 20, 2026
- Tools that change things, listed without credentials: 7 to 10
- Oct 29, 2026
- Tools that change things, listed without credentials: 6 to 7
Findings
Matches of fixed checks, with the text they matched.
The server marks "particle_alert_preview" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"openWorldHint":false}; The name "particle_alert_preview" says "preview": a word for reading.
The server marks "particle_topic_browse" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "particle_topic_browse" says "browse": a word for reading.
The description is 3,201 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...rt's definition and its matched results are stored as part of the alerts feature."
- Infoparticle_catalog
The description is 3,484 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...ls instead. Discovery is free; tool execution is metered and plan-gated as usual."
The description mentions "credentials".
What this check looks forMatched text
description: "...is speaking by occupation, profession, credentials or industry ("doctors", "medical profes..."
The input schema at properties.include.description mentions "credential".
What this check looks forMatched text
inputSchema.properties.include.description: "...he guest_ filters accept, organization, credential). Default response is lean — request on..."
Show 7 more findingsShow fewer
The description is 6,226 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...s the filter with `sort: "strength"` on `particle_podcast_find_mentions` instead."
The description is 3,056 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...old about new mentions as they air, create an alert with `particle_alert_create`."
The description is 2,907 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...lume over time and the shows carrying it (`particle_podcast_get_mention_trends`)."
The input schema at properties.standing.description mentions "credential".
What this check looks forMatched text
inputSchema.properties.standing.description: "...: 'established' (conferred by others: a credential, a position, recognition in the field),..."
The description is 3,194 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...n a recent window, use `particle_expertise_get` with `include: ["top_podcasts"]`."
The description mentions "credentials".
What this check looks forMatched text
description: "...ished"` or `guest_practicing=true` when credentials matter); never stand the profession in..."
The description is 7,016 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...s the filter with `sort: "strength"` on `particle_podcast_find_mentions` instead."
History
Changes to its tool definitions and to its remote endpoint, newest first.
PostureRemote posture changed. Tools that change things, listed without credentials: 7 -> 10.View diff
- Tools that change things, listed without credentials: 7 to 10
Tools6 added, 1 changed.+6 added~1 changedView diff
- Added:particle_company_list_peopleOnly reads
- Added:particle_report_createCan't be undone
- Added:particle_report_deleteDeletes or cancels
- Added:particle_report_getOnly reads
- Added:particle_report_listOnly reads
- Added:particle_report_updateDeletes or cancels
- Changed:particle_catalogOnly readsdescription
Tools6 added, 14 changed.+6 added~14 changedView diff
- Added:particle_company_get_statement_characteristicsOnly reads
- Added:particle_person_get_statement_characteristicsOnly reads
- Added:particle_podcast_compare_share_of_voiceOnly reads
- Added:particle_podcast_get_entity_chartOnly reads
- Added:particle_podcast_get_transcription_requestOnly reads
- Added:particle_podcast_request_transcriptionChanges things
- Changed:particle_alert_createDeletes or cancelsdescriptioninputSchema
- Changed:particle_alert_previewChanges thingsinputSchema
- Changed:particle_alert_updateDeletes or cancelsdescriptioninputSchema
- Changed:particle_catalogOnly readsdescription
- Changed:particle_expertise_resolveOnly readsdescription
- Changed:particle_podcast_find_mentionsOnly readsdescriptioninputSchema
- Changed:particle_podcast_get_episodeOnly readsdescriptioninputSchema
- Changed:particle_podcast_get_guestOnly readsdescriptioninputSchema
- Changed:particle_podcast_get_mention_trendsOnly readsdescriptioninputSchema
- Changed:particle_podcast_get_rankingsOnly readsdescriptioninputSchema
- Changed:particle_podcast_get_share_of_voiceOnly readsdescriptioninputSchema
- Changed:particle_podcast_list_guestsOnly readsdescription
- Changed:particle_podcast_resolveOnly readsinputSchema
- Changed:particle_podcast_search_transcriptsOnly readsdescriptioninputSchema
PostureRemote posture changed. Tools that change things, listed without credentials: 6 -> 7.View diff
- Tools that change things, listed without credentials: 6 to 7
Install
Pinned to version 1.0.0. Values in angle brackets are yours to fill in.
claude mcp add --transport http particle-pro https://mcp.particle.proclaude mcp add --transport http particle-pro https://mcp.particle.proRun in a terminal.
Claude Code permissions
Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.
{
"permissions": {
"allow": [
"mcp__particle-pro__particle_alert_get",
"mcp__particle-pro__particle_alert_list",
"mcp__particle-pro__particle_alert_list_matches",
"mcp__particle-pro__particle_catalog",
"mcp__particle-pro__particle_company_get",
"mcp__particle-pro__particle_company_get_statement_characteristics",
"mcp__particle-pro__particle_company_list_people",
"mcp__particle-pro__particle_company_resolve",
"mcp__particle-pro__particle_entity_get",
"mcp__particle-pro__particle_entity_resolve",
"mcp__particle-pro__particle_expertise_get",
"mcp__particle-pro__particle_expertise_resolve",
"mcp__particle-pro__particle_person_get",
"mcp__particle-pro__particle_person_get_statement_characteristics",
"mcp__particle-pro__particle_person_resolve",
"mcp__particle-pro__particle_podcast_compare_share_of_voice",
"mcp__particle-pro__particle_podcast_find_mentions",
"mcp__particle-pro__particle_podcast_get_entity_chart",
"mcp__particle-pro__particle_podcast_get_episode",
"mcp__particle-pro__particle_podcast_get_episode_timeseries",
"mcp__particle-pro__particle_podcast_get_guest",
"mcp__particle-pro__particle_podcast_get_mention_trends",
"mcp__particle-pro__particle_podcast_get_rankings",
"mcp__particle-pro__particle_podcast_get_share_of_voice",
"mcp__particle-pro__particle_podcast_get_transcription_request",
"mcp__particle-pro__particle_podcast_list_clips",
"mcp__particle-pro__particle_podcast_list_episodes",
"mcp__particle-pro__particle_podcast_list_guests",
"mcp__particle-pro__particle_podcast_list_related",
"mcp__particle-pro__particle_podcast_list_related_episodes",
"mcp__particle-pro__particle_podcast_resolve",
"mcp__particle-pro__particle_podcast_search_transcripts",
"mcp__particle-pro__particle_report_get",
"mcp__particle-pro__particle_report_list"
],
"ask": [
"mcp__particle-pro__particle_alert_preview",
"mcp__particle-pro__particle_podcast_request_transcription",
"mcp__particle-pro__particle_report_create",
"mcp__particle-pro__particle_topic_browse"
],
"deny": [
"mcp__particle-pro__particle_alert_create",
"mcp__particle-pro__particle_alert_delete",
"mcp__particle-pro__particle_alert_update",
"mcp__particle-pro__particle_call",
"mcp__particle-pro__particle_report_delete",
"mcp__particle-pro__particle_report_update"
]
}
}Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as particle-pro. Review it before you use it.
Capability tags behind 40 rules
- mcp__particle-pro__particle_alert_create untrusted-input
- mcp__particle-pro__particle_alert_get private-data, untrusted-input
- mcp__particle-pro__particle_alert_update untrusted-input
- mcp__particle-pro__particle_call untrusted-input
- mcp__particle-pro__particle_catalog untrusted-input
- mcp__particle-pro__particle_company_get untrusted-input
- mcp__particle-pro__particle_company_get_statement_characteristics untrusted-input
- mcp__particle-pro__particle_company_list_people untrusted-input
- mcp__particle-pro__particle_company_resolve untrusted-input
- mcp__particle-pro__particle_entity_get untrusted-input
- mcp__particle-pro__particle_entity_resolve untrusted-input
- mcp__particle-pro__particle_expertise_get untrusted-input
- mcp__particle-pro__particle_expertise_resolve untrusted-input
- mcp__particle-pro__particle_person_get untrusted-input
- mcp__particle-pro__particle_person_get_statement_characteristics untrusted-input
- mcp__particle-pro__particle_person_resolve untrusted-input
- mcp__particle-pro__particle_podcast_compare_share_of_voice untrusted-input
- mcp__particle-pro__particle_podcast_find_mentions untrusted-input
- mcp__particle-pro__particle_podcast_get_entity_chart untrusted-input
- mcp__particle-pro__particle_podcast_get_episode untrusted-input
- mcp__particle-pro__particle_podcast_get_episode_timeseries untrusted-input
- mcp__particle-pro__particle_podcast_get_guest untrusted-input
- mcp__particle-pro__particle_podcast_get_mention_trends untrusted-input
- mcp__particle-pro__particle_podcast_get_rankings untrusted-input
- mcp__particle-pro__particle_podcast_get_share_of_voice untrusted-input
- mcp__particle-pro__particle_podcast_get_transcription_request untrusted-input
- mcp__particle-pro__particle_podcast_list_clips untrusted-input
- mcp__particle-pro__particle_podcast_list_episodes untrusted-input
- mcp__particle-pro__particle_podcast_list_guests untrusted-input
- mcp__particle-pro__particle_podcast_list_related untrusted-input
- mcp__particle-pro__particle_podcast_list_related_episodes untrusted-input
- mcp__particle-pro__particle_podcast_request_transcription untrusted-input
- mcp__particle-pro__particle_podcast_resolve untrusted-input
- mcp__particle-pro__particle_podcast_search_transcripts untrusted-input
- mcp__particle-pro__particle_report_create untrusted-input, outbound
- mcp__particle-pro__particle_report_delete untrusted-input
- mcp__particle-pro__particle_report_get untrusted-input
- mcp__particle-pro__particle_report_list untrusted-input
- mcp__particle-pro__particle_report_update untrusted-input
- mcp__particle-pro__particle_topic_browse untrusted-input
Pin
Keep the decision: fail CI when the tools change, follow every change, or show a badge.
Pin in CI
Fail a build when the tools you reviewed are not the tools the server serves today.
curl -s "https://radar.anlyon.com/api/v1/servers/pro.particle/particle-pro/verify?hash=8a5a75caeb54eb4fa48847c2ea376a2b8a360f17878678255351ef23e98a9e53" | jq -e '.changed == false'Pinned hash 8a5a75caeb54, from Nov 19, 2026, 02:17 UTC.
Watch
Get told when its tools change: a new tool, a new description, a new class.
https://radar.anlyon.com/servers/pro.particle/particle-pro/changes.xmlAn Atom feed. Works in any feed reader or Slack's RSS app.
Badge
[](https://radar.anlyon.com/servers/pro.particle/particle-pro)Source: MCP Registry. Synced Oct 21, 2026, 18:54 UTC.
particle-pro MCP server: questions and answers
Answered from the scan above, not from the publisher's description.
Is the particle-pro MCP server safe?
- No scan can promise that. What its definitions show: 44 tools, 10 of which can change, send or delete something, and 13 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.
Can the particle-pro MCP server delete data?
- Yes. 6 tools can delete, cancel or revoke something: particle_alert_create, particle_alert_delete, particle_alert_update, particle_call, particle_report_delete and particle_report_update.
Can the particle-pro MCP server do things that cannot be undone?
- Yes. 1 tool can send, pay, publish or merge: particle_report_create.
What tools does the particle-pro MCP server have?
- 44 tools: 6 destructive, 1 irreversible, 3 write, 34 read. particle_alert_create, particle_alert_delete, particle_alert_update, particle_call, particle_report_delete, particle_report_update, particle_report_create, particle_alert_preview and 36 more.
Does the particle-pro MCP server need sign-in or OAuth?
- Its remote endpoint listed its tools to an anonymous client, without sign-in.
Does the particle-pro MCP server send data to outside services?
- 1 tool can carry data out (it sends, posts or publishes, or takes a recipient, channel or URL): particle_report_create.
Has the particle-pro MCP server changed its tools?
- Yes, 2 times since Anlyon Radar started tracking it, most recently on Nov 19, 2026. Every change is on this page and in its Atom feed.