Cross-domain census of approved-but-not-completed work, by cause and type.
Scored across 6 tools
Most tools target clearly different actions or resources: emit_record writes records, register_producer manages producers, verdict looks up approvals, and weekly_report aggregates data. The main ambiguity is between account and subscribe, since both deal with plan/trial/billing state, though one is read-oriented and the other is an action.
The tool names mix noun-only names (account, verdict), verb-only names (subscribe), verb_noun names (emit_record, register_producer), and a noun phrase (weekly_report). They remain readable and domain-specific, but there is no single predictable naming convention.
Six tools is a well-scoped size for this domain, covering account state, record emission, producer registration, subscription, verdict lookup, and weekly reporting. Each tool appears to earn its place without excessive surface area.
The set covers core write paths and some read paths, including producer registration, record emission, verdict lookup, reporting, account inspection, and subscription. However, there are notable gaps: no tools to list or retrieve emitted records, manage or revoke producers, or cancel/change an existing subscription.
Account, plan, trial state, producers, meter
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry full behavioral disclosure. It only lists topics and says nothing about whether the tool is read-only, what it returns, authentication needs, or any other behavior. This is a complete absence of transparency.
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?
The description is a single short phrase, but it is a fragment rather than a structured sentence. It lacks a clear subject-verb structure and is under-specified for an agent to understand its role, making it more a label than a concise description.
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?
Given zero parameters and no output schema, the description should at least state what the tool returns or does. It only lists topics, providing no indication of operation or return values, leaving significant gaps for an agent to infer usage.
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 no parameter semantics to document. Per the baseline rule for 0 parameters, a score of 4 is appropriate.
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 is a list of nouns (account, plan, trial state, producers, meter) with no verb or operation specified. It restates the tool name 'account' and adds related terms, but does not clarify what the tool actually does or how it differs from siblings like emit_record or weekly_report.
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 guidance on when to use this tool, what alternatives exist, or any preconditions. The presence of siblings with clearer action names (emit_record, register_producer) makes the lack of differentiation more pronounced.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Emit one signed census record {record} — same ingest discipline and billing as POST /records
| Name | Required | Description | Default |
|---|---|---|---|
| record | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does disclose two meaningful traits: the call is billable and subject to 'ingest discipline' (validation/acceptance rules). It does not state whether the signing is done server-side or must be supplied, whether the operation is idempotent, what permissions are required, or what happens on duplicate/rejected records.
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 front-loaded sentence with no wasted clauses; the resource and its key behavioral hook (billing/ingest parity) come first. It is tight, though the compression into jargon costs some readability.
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?
This is a mutating, billable tool with no annotations, no output schema, and an unconstrained nested object parameter. The description leaves the record's required fields, signing responsibility, failure behavior, and cost implications undefined, deferring to an external endpoint spec the agent may not have access to.
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 single parameter is a nested object with 0% schema description coverage, and the description only restates it ('{record}') plus the word 'signed'. The internal shape of the record object — the one thing an agent actually needs — is entirely undocumented, pointing instead to an external POST /records contract.
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 concrete verb (emit) and resource (one signed census record), which is specific enough to act on. No sibling (account, register_producer, subscribe, verdict, weekly_report) overlaps with record emission, so explicit differentiation isn't required, but the jargon ('census record', 'signed') is left undefined.
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?
The clause 'same ingest discipline and billing as POST /records' gives an implied mental model — use this where you'd POST a record — but there is no explicit when-to-use, when-not-to-use, or prerequisite/permission guidance. Usage is only inferable from the external endpoint reference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Register a producer {producer_id, public_key (Ed25519 hex), types[]} — key-swap rejected
| Name | Required | Description | Default |
|---|---|---|---|
| types | Yes | ||
| public_key | Yes | ||
| producer_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It discloses one important constraint ('key-swap rejected') but omits permissions, idempotency, uniqueness of producer_id, side effects, and return behavior for a mutation operation.
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 compact sentence with no wasted words, and the constraint is front-loaded. However, the brace-list style is terse and could be clearer without adding much length.
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?
The tool has three required parameters, no annotations, no output schema, and 0% schema description coverage, yet the description only covers basic purpose and one rejection rule. It is insufficient for an agent to invoke the tool confidently in all relevant cases.
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 0%, so the description must compensate. It identifies all three parameters and gives the public_key format (Ed25519 hex), but producer_id format and the meaning/content of types[] remain unexplained.
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: 'Register a producer'. The embedded field list and 'key-swap rejected' further specify the operation, but it does not explicitly distinguish itself from siblings, though none appear to be registration tools.
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?
Provides no when-to-use guidance, no prerequisites, and no alternatives. The agent must infer that this is used to register a new producer and cannot tell when to choose a different tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Subscribe {tier: solo|fleet|scale} via the X-PAYMENT header on the MCP request
| Name | Required | Description | Default |
|---|---|---|---|
| tier | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral-disclosure burden. It usefully reveals that an X-PAYMENT header is required, which is meaningful context beyond the schema, but it omits side effects, billing recurrence, idempotency, failure behavior, and what happens after subscription.
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?
The description is a single front-loaded sentence with no wasted language, and the tier values plus payment-header requirement are stated immediately. The brace notation is slightly cryptic but still compact and information-dense.
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 payment-related subscription tool with no annotations, no output schema, and 0% schema description coverage, the definition is too thin. It identifies the tier values and payment header but omits what subscribing actually changes, what is returned, and how errors are handled.
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 0%, so the description must compensate for the undocumented tier parameter. It does provide the allowed values solo|fleet|scale, but it does not explain what each tier means or how they differ.
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 gives a specific verb, 'Subscribe', and identifies the tier parameter with its allowed values, so the action is largely clear. It does not clarify what the subscription grants or distinguish it from sibling tools such as account, leaving some scope ambiguity.
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?
The description does not state when to use subscribe versus alternatives like account or register_producer, nor does it mention prerequisites beyond the X-PAYMENT header. An agent must infer the usage context entirely from the tool name and one sentence.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Per-approval verdict {approval_id} — $0.01 x402 / subscription included (same billing as HTTP)
| Name | Required | Description | Default |
|---|---|---|---|
| approval_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so the description carries the full burden. It does disclose a genuine behavioral trait the schema can't: cost ($0.01 x402), subscription inclusion, and billing parity with HTTP. However it says nothing about whether the call mutates state, whether verdicts are cached, or what happens on an unknown approval_id — critical gaps for an unannotated tool.
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 compact sentence with no filler, and billing context is parenthetical rather than front-loaded. Brevity here shades into under-specification rather than efficiency.
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?
No output schema and no annotations, so the description should explain the return value and side effects; it explains neither. Pricing is covered, but an agent cannot confidently call this correctly or interpret the result.
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?
One required parameter at 0% schema description coverage. The description only echoes the placeholder {approval_id} without stating its format, where it comes from, or how to obtain one. It does not compensate for the coverage gap.
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?
"Per-approval verdict {approval_id}" names a resource but supplies no verb — an agent cannot tell whether this fetches, computes, records, or casts a verdict. Against siblings like emit_record and weekly_report it is not distinguishable in operation type. It largely restates the tool name plus a parameter placeholder.
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 when-to-use, when-not-to-use, or alternative is mentioned. Nothing tells the agent how this relates to emit_record, subscribe, or account, even though they plausibly overlap in a workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Weekly roll-up {start, end} (epoch seconds; defaults trailing 7 days) — first report free per operator ever, then subscription
| Name | Required | Description | Default |
|---|---|---|---|
| end | No | ||
| start | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose two valuable traits: default range of trailing 7 days and a monetization rule (first report free per operator, then subscription). It says nothing about the report contents, latency, or what failure looks like when no subscription exists.
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, front-loaded with the resource and range, with the billing caveat trailing. The curly-brace notation is terse but not wasteful; every clause carries information.
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 two-param, zero-required tool with no annotations and no output schema, the description covers parameters and cost but leaves the agent guessing about the report's contents and the behavior when the free quota is exhausted.
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 0% (bare numeric types only), so the description must compensate, and it does: it names both parameters, gives the unit (epoch seconds), and states the default when omitted. Required-count is zero, consistent with the described defaults.
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 and output shape: a weekly roll-up over a start/end range. It does not mention how it differs from siblings like account or verdict, so it falls short of the 5 bar, but an agent can still 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?
Usage is only implied: the weekly cadence and the 'defaults trailing 7 days' behavior suggest when it fits, and the billing note hints at a precondition. Nothing tells the agent when to prefer this over another tool, or what happens if the operator's free report has already been used.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
accountemit_recordregister_producersubscribeverdictweekly_reportPer-principal census of MCP subscriptions and durable tasks, with verified-stop receipts.
Audit any domain or agent for A2A, MCP, x402, MPP, ERC-8004, and Poppy readiness.
Cross-sector triage and intake for economic signals, demand, bottlenecks and capabilities.
Unpaid qualification-gated operational_context canary. Staging data. No wallet.
Add one secure layer between your agents and this server.