distribution
Server Details
Priced X creators, campaigns from a goal, plan changes, mandated payment links, proof and results.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 6 tools
The six tools have largely distinct purposes: company context, feedback, guest capability status, inventory coverage, guest pricing, and audience fit. The only potential overlap is between inventory and resolve_audience, both of which report per-channel coverage, but their scopes (network reach vs. campaign/profile fit) are clarified in the descriptions.
All names use snake_case, which is consistent, but the structural pattern is mixed: brain_get and feedback_send follow noun_verb, resolve_audience follows verb_noun, and guest_status, inventory, and plan_quote_guest are noun phrases or multi-word noun constructions. The result is readable but not predictable from a single naming convention.
Six tools is a well-scoped size for this distribution API, covering context, feedback, guest status, inventory, pricing, and audience fit without redundancy. Each tool appears to serve a distinct function, so none feels superfluous.
The set covers read/compute and feedback operations, but it lacks a tool to claim/create an account key or to create an actual distribution plan, even though guest_status and plan_quote_guest reference those next steps. Campaign creation/management and authenticated plan execution also appear absent, leaving clear gaps beyond guest exploration.
Available Tools
6 toolsbrain_getCompany contextBRead-onlyIdempotentInspect
Your company context as confirmed in the workspace (name, summary, audience), its version and the version history. Optionally one section.
| Name | Required | Description | Default |
|---|---|---|---|
| section | No | One section. Leave out for the whole context. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and closed-world, so the safety profile is covered. The description contributes that version and version history are returned, which is useful added context, but says nothing about authentication, workspace scoping behavior, or whether the context can be stale.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense sentence that front-loads the resource and its contents, with only minor redundancy in 'its version and the version history'. No filler sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter read tool with no output schema, the description covers the returned fields (name, summary, audience, version, history) well enough to set expectations. It stops short of describing the shape of the version history or how the context is scoped, but nothing critical for invocation is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the single enum parameter is fully documented in the schema ('Leave out for the whole context'). The description's 'Optionally one section' merely restates the schema, adding no format or semantic detail beyond it, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific resource ('company context') and enumerates its parts (name, summary, audience) plus version/version history, so an agent knows what comes back. It gives no differentiation from siblings such as resolve_audience, which retrieves overlapping audience data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use or when-not-to-use guidance and no mention of alternatives (e.g., resolve_audience) even though a sibling covers similar audience territory. The only conditional, 'Optionally one section,' is a parameter note rather than selection guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
feedback_sendSend feedbackAInspect
Tell the distribution team about a problem or an idea, with any valid key, without asking the user first. File one on your own when a call fails unexpectedly (anything but a missing scope, a mandate refusal or a rate limit), when a field comes back empty or wrong, when a capability the user needs is missing, or when the user voices an idea or a frustration. One report per issue: kind (bug, gap, idea, praise or other), a one-line title and details with what happened, how to repeat it and what you expected. Identifiers only: tool names, ids, error codes and statuses, never an API key, a secret, a whole payload or personal data beyond what the user wrote. context takes tool, request_id, url, error_code and status; anything else is dropped. Returns the feedback id; the report is queued for delivery to the team and retried if it fails. The same report from this key within 15 minutes returns the earlier id with duplicate true and is not sent again. 20 a brand an hour.
| Name | Required | Description | Default |
|---|---|---|---|
| kind | Yes | bug, gap (a missing capability or an empty or wrong field), idea, praise or other. | |
| title | Yes | One line: what happened or what is missing. | |
| context | No | Where it happened: the tool, request id, URL, error code and HTTP status. Other keys are dropped. | |
| details | Yes | What happened (the exact error), how to repeat it (the call), what you expected. Identifiers only. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare a non-read-only, non-destructive, non-idempotent write. The description adds substantial context beyond them: the report is queued and retried on failure, the return is the feedback id, identical reports within 15 minutes return the earlier id with duplicate true and are not re-sent, and there is a 20-per-brand-per-hour cap. It also states data-handling limits (identifiers only, context keys silently dropped), though it does not spell out permission or auth requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Dense but front-loaded: the core action and its triggers come first, then data-handling limits, then return and rate-limit behavior. It is long and slightly repetitive with the schema wording, but virtually every sentence carries operational information rather than filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description correctly supplies the return contract (feedback id, duplicate true on dedup) plus delivery, retry and rate-limit behavior. Nothing an agent needs to call this tool correctly and interpret its response is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is already 100%, so the baseline is 3, but the description adds real meaning: context accepts only tool, request_id, url, error_code and status with anything else dropped, and details should carry what happened, how to repeat it and what was expected using identifiers only. That goes beyond the schema's field-level docs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: reporting a problem or idea to the distribution team, with the exact content required (kind, one-line title, details). It is unmistakably distinct from siblings like inventory, guest_status or resolve_audience, so an agent can route to it without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit when-to-use with concrete triggers (a call failing unexpectedly, an empty or wrong field, a missing capability, user frustration or an idea) and explicit when-not conditions (missing scope, mandate refusal, rate limit). It also instructs the agent not to ask the user first, removing ambiguity about autonomy.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
guest_statusGuest accessARead-onlyIdempotentInspect
No account needed. What this connection can do without a key: which tools answer now, which need an account, and claim, where to sign in and create a key in Developers.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnly, idempotent, non-destructive, and closed-world behavior, so the bar is lower. The description still adds real value by disclosing the authentication requirement ('with a key' vs. without) and enumerating what the response covers (available tools, gated tools, sign-in/claim path), which goes beyond the structured hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
It is short and front-loads the key fact ('No account needed'), and every clause describes part of the result set. The run-on list in the second sentence is a little disorganized but wastes no sentences on filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description must carry the return-value burden, and it does by naming the three things reported: currently answering tools, tools needing an account, and the claim/sign-in location. Combined with annotations covering safety, an agent has enough to call it correctly, though the wording could be tighter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate; per the rubric a 0-parameter tool baselines at 4. The description correctly implies no input is required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description conveys the resource (what an unauthenticated/guest connection can access) but never states a clear verb such as 'reports' or 'lists'; it opens with a fragment ('No account needed') and ends in a garbled clause ('and claim, where to sign in'). An agent can infer the purpose, but the muddled phrasing makes it less than fully clear, and no sibling tool is referenced.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'No account needed' implies the tool is callable before authentication, which hints at when it applies. However, there is no explicit statement of when to use this versus the siblings (brain_get, inventory, plan_quote_guest) or of any exclusions, so the guidance remains implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
inventoryNetwork coverageBRead-onlyIdempotentInspect
How well the network reaches your own audience today, per channel: approved creators and posts on sale at a current price, and whether coverage is strong or thin. Counts only, never a creator's identity.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this a read-only, idempotent, non-destructive, closed-world operation. The description adds genuinely useful context beyond that: it is count-only, never exposes creator identity (a privacy guarantee), is scoped to approved creators and posts currently on sale, and classifies coverage as strong or thin.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that front-loads the core meaning (network reach to your own audience, per channel) and appends the key qualifier (counts only, no identity). It is dense and a little run-on, but there is no wasted sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no input parameters and no output schema, the description has to carry the return semantics, and it does reasonably: per-channel counts, a strong/thin coverage signal, and an explicit privacy constraint. The exact shape of the result (e.g., what a channel entry looks like) remains unspecified, which keeps it from a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the baseline for this dimension is 4. Nothing in the description is needed to disambiguate inputs, and it does not introduce any confusing parameter-like language.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explains that this reports how well the network reaches your own audience, per channel, as counts, which is a coherent resource. However, it never states a verb ("returns", "reports") and the name/title mismatch ("inventory" vs "Network coverage") plus the lack of any contrast with siblings like resolve_audience leaves the exact purpose somewhat vague.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance, no prerequisites, and no mention of alternatives. The closest sibling, resolve_audience, is not referenced even though both concern audience reach, leaving the agent to guess which to call.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
plan_quote_guestEstimate a planARead-onlyIdempotentInspect
No account needed. The all-in price range a brand pays per post in one format (post, quote or thread) across every creator on sale now, and that range times the number of posts you name (1 to 50), with how many creators sell that format and when the numbers were read. A range, not a plan: a plan names creators and dates and needs an account (claim says where to sign in and create a key).
| Name | Required | Description | Default |
|---|---|---|---|
| posts | No | How many posts, 1 to 50. Default 1. | |
| format | No | post (an original post), quote (a quote repost) or thread. Default post. | post |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only/idempotent/non-destructive safety, but the description adds genuinely useful context beyond them: no authentication required, the response is a range (not a commitment), and it reports how many creators sell the format and when the data was read. That freshness/coverage disclosure is exactly the kind of behavioral detail annotations cannot express.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
'No account needed' is well front-loaded, but the core sentence is a long run-on that buries the subject ('The all-in price range ... and that range times the number of posts ... with how many creators ...') and forces re-reading. The plan-vs-range caveat is useful but the overall packaging is dense rather than economical.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description correctly takes on the burden of describing the return: price range, creator count, and read timestamp. It also covers the auth model and the range/plan distinction. The only gap is that it never states a currency or unit for the range, leaving the numeric output under-specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3, but the description adds interpretation: 'posts' scales the per-post range (the range times the number of posts) and the format options are glossed as original post, quote repost, or thread. This explains how the two parameters combine to form the result, which the schema alone does not.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description concretely defines the output: an all-in price range a brand pays per post in a given format, multiplied by the number of posts, plus creator count and data recency. It also cleanly distinguishes itself from a real 'plan' (which names creators and dates). The verb itself is implicit (the title says 'Estimate'), making it slightly less crisp than a 5, but the resource and scope are unmistakable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'No account needed' states the key usage precondition for this guest tool and contrasts it with a plan that requires an account/key. However, it never routes the agent among the actual siblings (inventory, resolve_audience, guest_status) or explains when to reach for a guest estimate versus an authenticated plan. Usage is implied rather than spelled out.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
resolve_audienceResolve an audienceARead-onlyIdempotentInspect
The audience fit for one of your campaigns (intent_id) or for a profile you describe (product, audience, geography): the audience segments it matches and the coverage per channel. The same check a campaign gets when it starts.
| Name | Required | Description | Default |
|---|---|---|---|
| product | No | What is being promoted. | |
| audience | No | Who it is for, in your words. | |
| geography | No | Where the audience is, or worldwide. | |
| intent_id | No | One of your campaigns. Leave out to describe a profile instead. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds that this is a lookup returning matched segments and coverage, and that it mirrors campaign-start behavior, but does not add richer traits such as latency or scoping limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences, front-loaded with the outcome and modes; the parenthetical labels efficiently tie inputs to modes. No filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only, idempotent lookup with no output schema, the description usefully describes the return content (segments plus coverage per channel), which compensates for the absent output schema. Remaining gaps are minor.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description restates the parameter roles (intent_id, product, audience, geography) and the campaign-vs-profile dichotomy, which the schema already documents, adding no new syntax or constraint details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the resource (audience fit) and its two input modes (campaign intent_id vs. described profile) and states what it returns (audience segments and per-channel coverage). It is a clear noun-phrase statement rather than a crisp verb, but an agent can tell what it produces.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly distinguishes the two invocation paths — supply intent_id for an existing campaign, or supply product/audience/geography to describe a profile — and frames it as 'the same check a campaign gets when it starts.' It gives no when-not guidance or named alternatives, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
- First observed
brain_get - First observed
feedback_send - First observed
guest_status - First observed
inventory - First observed
plan_quote_guest - First observed
resolve_audience
Related MCP Connectors
x402 paid content and Nib Tips with pending holds, refunds, public ledger, pricing, and reputation.
Run a UPI creator support page from chat: supporters, goals, page, share assets. No money moves.
Optional creator-support terms and private contribution receipt tools for Gateway.
Public offers, events, approved proof, FAQs, and safe checkout links.
Related MCP Servers
- AlicenseAqualityBmaintenanceThe first commercial implementation of HTTP 402 Payment Required for creator content. AI agents discover music, video, and text catalogs as pre-indexed Pockets (list_pockets, search_pockets — free, no key) and pull licensed content per-use through a 402 paywall. Tiered per-pull pricing by content type; 85% of every pull pays the rights holder instantly, with attribution and an audit trail.3MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to manage creator profiles, sell digital products, and make USDC payments on Base using the x402 payment protocol through the Cobbee platform.35 npmMIT
- AlicenseAqualityAmaintenanceAgentic payments on Solana: an agent can pay x402 / HTTP 402 paywalls in USDC, hold a pre-paid balance or a subscription, and buy datasets or settle store checkouts. All 15 tools run behind fail-closed spending caps ($1 per payment, $10 per day by default), and settlement is non-custodial through a program-owned escrow that releases 99% to the creator.1881 npmMIT

fabler-x402-toolsofficial
AlicenseNot gradedqualityBmaintenanceEnables MCP clients to use paid tools for secret scanning, agent-config auditing, and OG image rendering, with payments handled over the x402 protocol on Base.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.