BNM Data Shop

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and largely delivers: it discloses the payment gate ('Unpaid returns HTTP 402'), the two-phase response behavior ('After a valid X-PAYMENT, the same URL returns JSON'), per-call pricing, and the empty-set behavior ('Empty new set is 304 or recordCount 0'). It does not describe the JSON payload structure, but the highest-risk behavior for an agent — paying and still getting a 402 — is clearly flagged.

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 compact with no filler, and front-loading the cost and payment address is sensible for a paid tool. But it is a single run-on paragraph that fuses URL, USDC address, pricing, resource identity, and pagination into one breathless stream of clauses, forcing the agent to untangle multiple embedded asides to extract the core semantics.

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 unusual aspects are covered well: payment gate, 402 behavior, pricing per mode, and watermark pagination. Missing are the relationship to sibling tools (especially 'ticks', whose subdomain the URL uses), the shape of the returned JSON (no output schema), and expected chunk size/content — gaps that matter for a paid tool an agent must choose among 47 alternatives.

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 schema already explains the tricky interactions ('Ignored when since/before is set', 'Empty new set is 304 or recordCount 0'), so the baseline is 3. The description adds the pricing differential per parameter (id=$0.02 vs chunk=$0.05) and the newest/older chunk orientation, but these are incremental to what the schema's own descriptions convey.

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 a specific verb and resource — 'UK AAIB investigation-report text GET' — and the AAIB agency reference distinguishes this from the dozens of sibling report tools. However, the purpose statement is embedded inside pricing clauses ('GET ?id= is one official text ($0.02)') and the cryptic 'Not a new SKU' muddies what exactly this tool is.

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 context is implied through the pagination semantics ('Newest chunk on a plain GET', '?before' for older chunks, '?since' for newer than a watermark) and the payment flow (402 until X-PAYMENT). But there is no explicit statement of when to choose this tool over alternatives — with 47 siblings including 'ticks', 'get-one', and 'search' and a URL hosted on ticks.bnm.farm, the relationship to those tools is left entirely to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden, and it is unusually transparent: it reveals that unpaid requests return HTTP 402, that a valid X-PAYMENT makes the same URL return JSON, and that pagination is chunk-based with watermark semantics. It also discloses that this is the same endpoint rather than a new SKU, avoiding a likely misunderstanding.

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 compact and contains no padding, but it is awkwardly structured: payment details and pricing are interleaved throughout, and the sentence fragments are dense enough to slow comprehension. It is information-efficient rather than clearly front-loaded, so it is adequate but not exemplary.

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 paid endpoint with no output schema and no annotations, the description covers payment, pricing, error behavior, pagination modes, and the X-PAYMENT mechanism. The main gap is that it never describes the shape of the returned JSON beyond saying it is JSON and mentions recordCount only inside a parameter description. Still, for a proprietary paid endpoint this is a strong level of context.

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 input schema already explains id, page, since, before, and x_payment in detail, so the baseline is 3. The description does add pricing context and the relationship between payment and the x_payment parameter, but it does not substantially expand parameter meaning beyond the schema.

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 states a specific verb and resource (GET air-letters) and identifies the domain: USDA APHIS AIR confirmation-letter text. It distinguishes fetching one official text by id from fetching chunked lists, which makes the core purpose clear. It does not explicitly contrast this tool with any sibling tool, so it falls just short of a 5.

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 gives concrete usage conditions for plain GET, ?id, ?before, and ?since, explaining which variant to use and what each costs. It also covers the payment requirement and the 402 behavior for unpaid requests. It does not explicitly say when to prefer air-letters over sibling tools, but the parameter-level usage guidance is strong.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses the paid nature of the API, the USDC payment address, the 402 response when unpaid, and the JSON response after a valid X-PAYMENT. It does not cover response structure or rate limits, but the most consequential behavioral traits are exposed.

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 compact and every sentence contributes pricing, access, or behavioral information, with the endpoint and payment model front-loaded. The punctuation is a bit run-on and 'GET' is repeated, but there is 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 paid external API with no output schema and no annotations, the description is fairly complete: it covers the endpoint, payment, authentication header, 402 error, JSON return, single-text id access, paging, and watermarking. It could include an example response or clearer sibling routing, but the operational contract is mostly sufficient.

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. The description mostly restates pricing and paging behavior that also appears in the parameter descriptions, such as 'that one official text, $0.02' and 'another $0.05.' It adds little semantic meaning beyond what the schema already provides.

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 clearly identifies a GET operation against a concrete URL and names the resource: USDA APHIS AWA inspection-report observation text. It explains what the tool returns (one official text by id, newest/older chunks by pagination). It does not explicitly contrast awa with sibling tools, so it stops short of full differentiation.

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 gives concrete usage modes: plain GET for the newest chunk, ?before for older chunks, ?since for texts newer than a watermark, and ?id for a single official text. It also explains the payment flow and the 402 failure mode. It does not provide explicit when-not-to-use guidance or alternatives among sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full responsibility for behavioral disclosure, and it does this thoroughly. It reveals that requests are paid, states exact prices, explains that unpaid requests return HTTP 402, and says the same URL returns JSON after a valid X-PAYMENT. It also clarifies chunking and watermark semantics, which are non-obvious and important for an agent to understand.

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 dense but efficient, front-loading the URL and pricing before explaining the parameter modes. Every sentence contributes either pricing, behavior, or a selection rule. It is not as tight as a two-sentence description, but the complexity of the paid paginated model justifies the 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?

Given no output schema and no annotations, the description covers a lot: cost, payment requirement, error behavior, chunking, and all available parameters. It does not fully spell out the JSON response shape or the payment acquisition flow, but it provides enough behavioral context for an agent to call the tool and interpret HTTP 402 vs. successful JSON responses.

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 schema already documents all five parameters. The description adds value by integrating the parameters into a coherent model: id is the $0.02 official text, plain GET/page gives the newest $0.05 chunk, before gives an older chunk, and since gives newer-than-watermark content. It also explains the outcome of a valid X-PAYMENT, which supplements the schema's parameter description.

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 clearly identifies a GET operation on a URL and states the resource: BIS institution charging-letter / order text. It explains the main retrieval modes (official text by id, newest chunk, older chunk, newer-than watermark), so an agent can tell what the tool does. It does not explicitly distinguish this from sibling tools by name, but the resource and pricing/payment model are distinctive.

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 gives explicit guidance on parameter-based usage: plain GET returns the newest chunk, ?before returns an older chunk, ?since returns newer-than-watermark content, and ?id retrieves a single official text. This is clear context for invoking the tool correctly. It does not explicitly discuss sibling-tool alternatives, but the selection rules among the tool's own modes are well articulated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and largely delivers: it discloses the pay-per-call pricing, the X-PAYMENT header requirement, that unpaid calls yield HTTP 402, and that a valid payment makes the same URL return JSON. It stops short of describing response shape, error bodies, or rate limits, but the important operational behaviors are surfaced.

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?

Around 70 words of genuinely useful content, but it is a stream of telegraphic fragments—no lead summary, no grouping of pricing vs. mechanics vs. behavior. The most identifying sentence ('BSEE District Accident Investigation Report text') comes after the payment address, forcing the agent to sift through payment trivia first.

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 5-parameter monetized endpoint with no output schema, the description covers the access protocol, payment trigger, and JSON success type. However, it omits the actual output structure, never mentions the page parameter, and leaves the relationship between before/since/page ambiguous (the schema clears it up). That is a real gap, but the schema compensates.

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% and the schema descriptions are unusually rich, already including pricing, 'not a new SKU', and ignore rules. The tool description adds almost nothing beyond echoing the same facts, 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?

The description identifies the resource as 'BSEE District Accident Investigation Report text' and signals GET as the verb, but it never states plainly that the tool retrieves that report. It reads like a pricing/access note ('$0.05 USDC on Base', 'Not a new SKU'), and the chunk/watermark language muddies what a single call actually returns. Among many sibling report tools, nothing distinguishes this one except the buried 'BSEE' label.

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 gives explicit call-mode conditions: ?id= fetches one official text, a plain GET fetches the newest chunk, ?before fetches an older chunk, and ?since fetches texts newer than a watermark. It also warns that unpaid calls return HTTP 402. It does not name sibling alternatives or say when not to use this tool, but the parameter-level routing is concrete enough to choose a correct call shape.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states payment requirements ($0.05), that unpaid requests return HTTP 402, and that a valid X-PAYMENT header makes the same URL return JSON. It also clarifies pricing differences and that this is not a new SKU, which is rich behavioral context for an agent.

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 dense but efficient: it packs URL, cost, payment address, operation modes, error behavior, and response format into a short paragraph. Every sentence contributes information. The opening sentence is slightly cluttered with the payment address, but overall it is a well-structured, appropriately sized 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 no output schema, the description does state that the response is JSON, which covers the return format at a high level. It also covers payment, error handling, and parameter selection. It does not describe the JSON structure, but for tool selection and invocation this is likely sufficient. The lack of output schema raises the bar slightly, but the description and schema together cover most practical needs.

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 adds meaningful semantic value beyond the schema by attaching costs to each parameter mode, clarifying that id is a different pricing tier, and that page is ignored when since/before is set. This is useful supplemental information, though the schema already covers most parameter meaning.

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 identifies a specific resource (FDA CDER Integrated Review text) and the operation is GET, with an explicit URL. It clearly explains the different retrieval modes (by id, newest chunk, older chunk, watermark), though it does not explicitly name a sibling tool to distinguish from. This is clear but not quite at the level of explicitly differentiating itself from siblings.

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 gives concrete guidance on which parameter/variant to use: plain GET for the newest chunk, ?before for an older chunk, ?since for texts newer than a watermark, and ?id for one official text. It provides clear context but does not discuss when to choose this tool over a sibling, only within-tool usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full behavioral burden and does so thoroughly: it discloses the paid nature, exact cost and destination, HTTP 402 when unpaid, the need for a valid X-PAYMENT to receive JSON, and chunk/pagination behavior. There is no contradiction with annotations since none exist.

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 compact and front-loaded with the URL and payment requirement. Every clause carries operational information, and the telegraphic style avoids filler while still covering payment, pagination, and access behavior.

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 description covers payment, authentication via X-PAYMENT, error behavior, pagination, and the distinction between official texts and chunks. It does not describe the concrete JSON response shape, but since no output schema exists and the schema mentions recordCount, the operational context is mostly sufficient for correct invocation.

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 each parameter already has a meaningful description, including pricing and mode semantics. The tool description largely restates or summarizes what the schema already says, adding little new parameter-level meaning, so the baseline 3 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 clearly identifies the resource as CFPB consent-order / administrative-order text retrievable via a paid GET endpoint, and distinguishes the main modes: plain GET for newest chunk and ?id for an official text. It is specific about the resource and verb, though it does not explicitly differentiate itself from sibling agency-order tools beyond the CFPB scope.

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 provides explicit usage guidance for each mode: plain GET for newest chunk, ?id for one official text, ?before for older chunks, and ?since for newer-than-watermark results. It does not name alternatives or state when not to use this tool, but the parameter-driven usage contexts are clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden and does disclose important behavior: unpaid requests return HTTP 402, a valid X-PAYMENT is required, and the endpoint returns JSON after payment. It does not describe response shape, but it is transparent about the payment gate and error condition.

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 short and front-loads the URL, but it reads as a dense run-on with repeated pricing details and the cryptic phrase 'Not a new SKU.' It could be clearer if split into purpose, payment, and behavior sections.

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 paid, paginated read endpoint with no output schema, the description covers the essential context: URL, cost, payment requirement, single-text vs chunk retrieval, watermark behavior, and the 402 failure case. The input schema fills in the remaining parameter semantics, and the response type is stated as JSON.

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 input schema already documents all five parameters. The description repeats the id/before/since semantics and adds pricing, but it does not meaningfully expand on what the parameter descriptions already tell the agent.

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 identifies a specific resource, CFTC enforcement-order/settlement text, and a clear retrieval operation via GET, including single-text and chunked retrieval modes. However, it does not explicitly differentiate this tool from the many sibling regulatory-order tools, and the payment details clutter the core purpose statement.

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 guidance on when to choose cftc-orders versus alternatives like cfpb-orders, fdic-orders, or frb-orders. The description only explains query-mode variations and payment behavior, not tool-selection context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full disclosure burden and does substantial work: it explains payment requirements, exact pricing, HTTP 402 on non-payment, JSON return after a valid X-PAYMENT, and chunk/watermark behavior. It does not cover rate limits or the JSON response shape, but the most important behavioral surprises are surfaced.

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 dense and front-loaded with the URL and resource, and every sentence contributes pricing, parameter, or payment behavior. Some sentences are telegraphic and grammatically awkward, but there is no wasted 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?

Taken together with the schema, the description covers the essential invocation decisions: which parameter to use, what each costs, and how payment failures behave. The lack of an output schema means the JSON structure is not described in advance, but for selecting and paying for this specific data endpoint the definition is adequately complete.

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 input schema already documents 100% of the parameters, so the baseline is 3; the description adds value by assigning costs to id, before, and since, clarifying that these are the same endpoint rather than new SKUs, and tying x_payment to the 402-to-JSON behavior. This additional semantic content justifies a score above baseline.

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 clearly identifies the resource (UK CMA CA98 infringement-decision text) and the operation (GET against a specific paid URL), including the different retrieval modes for official text and chunks. It is not a tautology, but it does not explicitly contrast this tool with sibling tools such as get-one or ticks, so differentiation relies mostly on the dataset name.

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 provides concrete usage conditions: plain GET for the newest chunk, ?id= for one official text, ?before= for older chunks, and ?since= for newer-than-watermark content. It does not give explicit when-not-to-use or alternative-tool guidance, but the parameter-level routing is clear enough for an agent to invoke the tool correctly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full behavioral burden and does it well: it discloses the $0.05 USDC payment requirement and recipient address, the HTTP 402 on unpaid requests, and the JSON response after a valid X-PAYMENT. This gives the agent crucial side-effect and failure-mode information before invocation.

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 core information is packed into a short, front-loaded description with the endpoint and payment terms first. The phrase 'Not a new SKU' is cryptic and does not clearly earn its place, which keeps this from a 5.

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 paid fetch with no output schema, the description is fairly complete: it covers cost, address, unpaid behavior, and response type. It still leaves the exact JSON shape and any handling of the 402 payment flow implicit, but those are minor for basic invocation.

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 schema already documents x_payment as an optional x402 value forwarded as the X-PAYMENT header. The prose mention of 'valid X-PAYMENT' reinforces that behavior but adds little new semantic detail beyond the structured description.

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 identifies the resource (US CSB final investigation report PDFs), the HTTP method, and the paid endpoint. It is clear enough to distinguish this tool from sibling report tools by its CSB-specific subject, though it never states a plain function verb like 'retrieves' and includes the cryptic 'Not a new SKU'.

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 explains the payment flow but gives no guidance about when to choose csb-reports over alternatives such as aaib-reports, get-one, or search. There is no when/when-not language or named alternative, so an agent has to infer selection from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the behavioral burden and does well: it discloses the USDC payment requirement, per-request costs, HTTP 402 on unpaid requests, and that the same URL returns JSON after a valid X-PAYMENT. It does not mention rate limits or any non-obvious side effects, but a paid GET is reasonably characterized.

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 compact and dense, front-loading the endpoint and payment requirement before the data-retrieval modes. The telegraphic structure and repeated 'Not a new SKU' are a little cryptic, but every sentence contributes information and nothing is padded.

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 five-parameter tool with no annotations and no output schema, the description covers payment, error behavior, and chunking well, but it never describes the shape of the returned JSON. An agent can start a call, but it cannot predict the response structure or fully understand page vs. before/since behavior from the description alone.

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 reinforces the cost and chunking intent of id, since, and before, but does not add new syntax or format details beyond what the schema already provides.

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 identifies the resource as 'FDA De Novo classification-order text' and states the operation is a GET, which is enough for an agent to tell it apart from the many regulatory-order siblings. However, the core purpose is embedded in a payment/billing sentence rather than a clear 'Retrieve...' statement, and 'Not a new SKU' adds ambiguity about what the tool is for.

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 gives clear context for selecting query modes: plain GET for the newest chunk, ?before for the older chunk, ?since for newer-than-watermark, and ?id for one official text. It does not name alternative tools or state exclusions, so it stops short of a full when-to-use vs. siblings explanation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full behavioral burden and does so thoroughly: it discloses payment requirements, the exact payment address and cost, HTTP 402 on unpaid requests, the need for X-PAYMENT, the JSON response format, pagination semantics, and empty-set behavior via 304 or recordCount 0.

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 dense but not bloated; every clause carries operational information. Some phrasing is awkward and the run-on structure could be cleaner, but it front-loads the URL and payment requirement and avoids 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 paid, paginated API with no output schema and no annotations, the description is remarkably complete. It covers authorization, pricing, error codes, response type, pagination rules, parameter interactions, and even edge cases like empty new sets. An agent has enough information to invoke it correctly.

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 input schema already covers all five parameters at 100%, so the baseline is 3. The description adds value by attaching pricing and access semantics to the parameters: ?id is the official text at $0.02, while ?since and ?before are priced chunk operations at $0.05, and it clarifies that page is ignored when since/before is set.

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 a specific resource (ECAB FECA Decision and Order text), a concrete access method (GET on the ticks.bnm.farm URL), and distinguishes retrieval modes by query parameter. It clearly tells an agent what this tool provides and separates it from the many sibling agency-document 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?

The description gives clear conditions for each usage mode: plain GET returns the newest chunk, ?before returns older chunks, ?since returns newer-than-watermark texts, and ?id returns one official text. It does not explicitly name alternatives or exclusions, but the context is strong enough for correct selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and discloses key behaviors: payment requirement, HTTP 402 when unpaid, JSON response after valid X-PAYMENT, and chunk/pagination semantics. It could also mention rate limits or result shape, but the core behavioral traits are well covered.

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 dense block that opens with a URL and payment address, which is not agent-relevant for tool selection. Key info is present, but the 'Not a new SKU' line and scattered pricing make it poorly structured and not front-loaded.

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-gated API with chunked retrieval, the description covers the essential operational details: pricing per mode, the 402 behavior, the X-PAYMENT flow, and the JSON return. It does not describe the response shape, but no output schema exists and the provided schema is rich enough to guide invocation.

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 repeats most parameter semantics already in the schema (id, since, before, page) and adds pricing context, but does not add substantial new meaning beyond what the schema provides.

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 clearly identifies the resource as 'EPA NEPA Environmental Impact Statement PDFs' and specifies the GET endpoint and retrieval modes (by id, newest chunk, older/newer chunks). It is not a tautology and the resource type distinguishes it from sibling report tools, though the purpose is buried among payment details.

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 provides clear context for when to use this tool: it is for EPA NEPA EIS PDFs and explains when to use plain GET vs ?id vs ?before vs ?since. It does not explicitly name alternatives or exclusions, but the domain-specific wording makes the intended use clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full transparency burden and does a good job: it reveals the paid nature of the endpoint, the USDC price, HTTP 402 when unpaid, and JSON after a valid X-PAYMENT. It also explains chunk ordering (newest, older, watermark), which is useful behavioral context beyond the schema.

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 dense paragraph that opens with the payment address before stating what the resource is. It mixes pricing, endpoint behavior, chunk semantics, and a cryptic 'Not a new SKU' aside, making it harder for an agent to parse quickly. The content is mostly relevant, but the ordering and run-on structure hurt scannability.

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 and no annotations, yet the description omits the return shape beyond 'JSON' and does not explain how page interacts with the newest-first ordering. It does cover the payment flow, 402 status, and X-PAYMENT requirement, so an agent can invoke the tool, but several operational details are left to the schema or are absent.

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. The description adds pricing details and reinforces the role of before/since/id, but the schema already documents that page is ignored when since/before is set and that x_payment is forwarded as a header. Thus the description adds marginal value rather than essential new meaning.

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 identifies the resource ('EMA human-medicine referral procedure text') and the main operations: plain GET returns the newest chunk, ?id= returns one official text, and ?before/?since retrieve specific ranges. It is clear about what the tool does, though it does not explicitly distinguish itself from sibling tools such as get-one or get-page.

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 provides concrete usage context for the parameters: plain GET for newest chunk, ?before for older chunks, ?since for newer-than-watermark content, and ?id for a single official text. However, it never explains when to choose ema-referrals over a sibling tool, and the closing 'Not a new SKU' is not actionable routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations present, the description carries the full disclosure burden, and it does a good job: it spells out the requirement to pay $0.05, the exact payment destination, the HTTP 402 when unpaid, and that the same URL returns JSON after a valid X-PAYMENT. It does not mention rate limits or security details, but the core paid-access behavior is clearly disclosed.

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 dense single paragraph mixing URL, pricing, 402 behavior, and the 'not a new SKU' note. It is understandable and front-loaded, but a clearer structure (separate cost, behavior, examples) would help an agent parse it quickly.

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 that there is no output schema and no annotations, the description covers the key elements an agent needs: endpoint, cost, payment condition, error handling, and a statement of the returned format (JSON). It is slightly thin on the actual response shape, but as a paid API endpoint it is enough to make a correct call.

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 schema already covers all 5 parameters (100%), but the description adds useful price and ordering semantics (id = one official text at $0.02, before= older chunk, since = watermark, plain GET = newest chunk). That goes beyond what a bare schema would tell an agent.

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 identifies a specific resource ('EPA OALJ Initial Decision and Order + text') and a specific HTTP verb (GET), which distinguishes it from sibling report tools by document type. It stops short of explicitly contrasting with siblings, so a 4 rather than a 5.

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 implied by the resource name and the parameter explanations (plain GET, ?before, ?since) rather than stated. There is no explicit when-to-use or when-not-to-use guidance relative to alternative tools, and no mention of when to prefer a sibling.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral disclosure burden. It clearly discloses the USDC price, payee address, HTTP 402 on non-payment, and JSON return after a valid X-PAYMENT. It also explains chunk/watermark behavior and that this is not a new SKU, though it stops short of describing rate limits or response structure.

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 text is dense and front-loaded with the URL and cost, and nearly every clause conveys a distinct operational fact. It would benefit from line breaks or bullet separation, but there is no filler and the closing 'Not a new SKU' is meaningful disambiguation.

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 paid, paginated API with no output schema and no annotations, the description plus rich schema notes provide the necessary invocation flow: pay, send X-PAYMENT, handle 402, and choose the retrieval mode via id/before/since/page. It only promises 'JSON' without specifying the response shape, but no output schema exists and parameter semantics are already well documented.

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 input schema already covers all five parameters, so the baseline is 3. The description adds value by tying each parameter to a distinct retrieval mode and price point, making the interaction model clearer than the schema's per-field notes alone.

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 opens with the HTTP verb and full URL, then names the exact content: 'EPA Part 22 CAFO / ESA administrative penalty letter text.' This is specific enough for an agent to distinguish it from the many sibling regulatory-letter tools without opening the 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?

It gives explicit per-mode usage conditions: plain GET returns the newest chunk, ?before retrieves older chunks, ?since retrieves newer-than-watermark content, and ?id fetches one official text. It does not name sibling alternatives or exclusions, but the context is clear enough to be more than merely implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burdencss. It discloses important behavior: unpaid requests return HTTP 402, a valid X-PAYMENT makes the same URL return JSON, and the API chunks results with before/since semantics. It stops short of describing the JSON response shape or overall success/error envelope, but the payment and pagination behavior is unusually explicit.

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 compact and front-loads the URL and price, then efficiently covers payment, pagination, and HTTP behavior in a few sentences. Some phrases are grammatically awkward, particularly 'text GET ?id= is one official text,' and 'Not a new SKU' is tangential rather than clarifying. Still, there is 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?

The description thoroughly covers pricing, payment requirements, HTTP 402, and pagination modes, and the schema fills in parameter details such as recordCount 0. However, with no output schema present, the description only says 'returns JSON' and does not describe what that JSON contains, how chunks are represented, or how an agent should consume the response. That is a real gap given the payment flow and paginated chunks.

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 input schema already documents all five parameters with 100% description coverage, and the main description mostly restates the same semantics with pricing labels. It adds useful cost information and the 'same door, not a new SKU' billing context, but it does not substantially enrich parameter meaning beyond what the schema provides, so the baseline 3 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 clearly identifies the endpoint as a GET for 'EPA EAB Unpublished Final Order / Board Order text,' so the tool's subject matter and operation are clear. It also explains that plain GET returns the newest chunk and ?id returns a specific official textikuha. However, it does not explicitly contrast itself with sibling tools like epa-alj except via the repeated billing note 'Not a new SKU,' which is not a true tool distinction.

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 gives concrete usage scenarios: plain GET for the newest chunk, ?id for an official text, ?before for an older chunk, and ?since for texts newer than a watermark. This gives a clear operational context for when to use each parameter combination. It does not name sibling alternatives or exclusionary criteria, but for the core retrieval flows the guidance is strong.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so well: it discloses the USDC payment amount and chain, the recipient address, HTTP 402 behavior on unpaid requests, the X-PAYMENT flow, and that the same URL returns JSON after payment. It also explains the cost difference between ?id and chunk queries. It does not detail response fields or rate limits, but for a paid x402 endpoint this is strong 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 dense, semicolon-separated run-on that front-loads the URL and payment address before the purpose. It includes repetition such as 'official text' and 'Not a new SKU.' It is informative but could be organized more cleanly.

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 the paid endpoint, absent annotations, rich parameter schema, and no output schema, the description supplies the critical payment and access behavior needed to invoke it correctly. It covers 402 handling, X-PAYMENT, and query variants, though it does not describe the JSON response shape. That omission is tolerable because no output schema is provided, but it leaves a minor gap.

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 schema already documents each parameter thoroughly. The description repeats some parameter meaning, such as ?id being one official text and ?before/?since controlling older/newer chunks, but adds little beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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 states a specific verb and resource: a GET to the FAA Civil Penalty Appeals Administrator Order text. The resource name clearly separates it from siblings covering other agencies. It could be sharper about how it differs from generic get-one/get-page tools, but the purpose is 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?

It explains the different query modes and costs for id, before, since, and plain GET, which is useful within-tool guidance. However, it gives no explicit guidance on when to choose this tool versus sibling tools or alternatives. Usage is implied by the resource and query variants.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It reveals a payment requirement ($0.05 USDC), an HTTP 402 for unpaid requests, and that a valid X-PAYMENT yields JSON. It also explains chunk behavior. However, it does not mention error handling beyond 402, or the structure of the JSON response, but it discloses the key transactional behavior.

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 jumbled mix of URL, payment, pricing, and pagination details without a clear lead sentence. It front-loads payment instead of the core purpose, and the 'Not a new SKU' remark adds confusion. It is under-specified in structure and not concise; the information could be rearranged into a clear format.

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 description covers the essential behaviors (payment, pagination, response format) and the schema documents all parameters. However, it lacks any description of the JSON structure or what the returned data contains, and the 'Not a new SKU' note is cryptic. For a 5-parameter tool with no output schema, it is moderately complete but leaves room for interpretation.

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 each parameter has a descriptive comment in the schema (e.g., id's 'Official catalog id', page's '1-based page'). The tool description adds some pricing context but does not meaningfully enhance parameter meaning beyond what the schema already provides. Baseline of 3 is appropriate since the schema does the heavy lifting.

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 identifies the resource as FCC Enforcement Bureau order text and implies a GET retrieval, but it buries this under payment instructions and URL details. It is clear enough for an agent to know it fetches FCC EB orders, though it does not explicitly compare to sibling order tools. The verb and resource are present, so it is above a vague baseline.

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 is given on when to choose this tool over siblings; it simply states what it does. It does offer usage directives for pagination (plain GET for newest, ?before for older, ?since for newer), which helps parameter selection but not tool selection. There are no exclusions or alternative references, so it is adequate but not explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure, and it delivers: it reveals the paid nature (USDC on Base, $0.05/$0.02 tiers), the failure mode (HTTP 402 without payment), the success mode (JSON after X-PAYMENT), and pagination/empty-set behavior ('304 or recordCount 0'). It even flags 'Not a new SKU' to avoid product confusion. This is unusually transparent for a tool definition.

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 dense single paragraph that mixes pricing, payment address, resource identification, and behavior into one run-on set of clauses. It is not bloated, but it is poorly structured—an agent must parse through payment details to get to semantics. Front-loading the purpose and then using a structured list for the ?id/?before/?since modes would have earned a higher score.

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 the complexity (paid API, multiple access modes, no output schema), the description covers the critical operational context: payment, 402 behavior, authentication via X-PAYMENT, and the meaning of each query parameter. It is missing an explicit statement of return format other than 'JSON', but for an agent invoking the tool this is sufficient. The edge case of an empty set is mentioned, which is more than most tools provide.

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 schema already documents each parameter, including pricing and edge cases (e.g., 'Ignored when since/before is set'). The tool description mostly restates the same semantics in prose rather than adding new meaning; the main addition is tying each parameter to the URL query string, but that is minor and already implied by the schema parameter names.

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 identifies the resource as 'FDIC institution consent-order / C&D text' and explains the plain GET returns the newest chunk, with ?id= for one official text. This makes the tool's purpose inferable, but it never states a clear verb like 'fetch' or 'list', and the opening line is dominated by pricing and payment address rather than a concise purpose statement. It is clear enough to differentiate from sibling agency-order tools by the 'fdic-orders' topic, but lacks the crisp specificity of the best examples.

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 gives explicit guidance on how to use each mode: ?id= for one official text, ?before for older chunks, ?since for newer-than-watermark, and plain GET for the newest chunk. It also explains that unpaid requests return HTTP 402 and a valid X-PAYMENT yields JSON. It does not, however, explicitly compare against sibling tools or state 'use this for FDIC orders, not for other agency orders', leaving that to inference from the tool name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and delivers: exact payment address and cost, HTTP 402 failure mode, X-PAYMENT header requirement, JSON response after payment, chunk/pagination semantics, and a 304/recordCount 0 edge case (in the since parameter). For a paid endpoint this is exceptional disclosure of auth, cost, and failure behavior.

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 information-dense with no fluff, but it is a comma-spliced run-on that buries the lede: it opens with the URL and payment address rather than the tool's purpose. Chunk semantics, error codes, and identity clarifications are packed into one hard-to-parse paragraph, and 'Not a new SKU' adds cryptic ambiguity rather than clarity.

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 description thoroughly covers access mechanics — payment, pricing, pagination, auth, and the 402 failure mode. However, with no output schema and no annotations, it never describes what the returned JSON actually contains (fields of a FERC order, whether a chunk is a list or full text), which is a meaningful gap for a paid tool where an agent must judge whether the result satisfies the user's request.

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 schema's own parameter descriptions are unusually rich — they already document pricing, chunk semantics, the page/since/before interaction, and the 304 edge case. The description adds framing around the overall pricing model but little per-parameter meaning beyond what the schema provides, so the baseline of 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?

The description identifies a specific verb and resource ('FERC institution stipulation-and-consent text GET') and the agency domain 'FERC' implicitly distinguishes it from sibling tools like cfpb-orders, cftc-orders, and fdic-orders. However, the core purpose is never stated plainly — it is embedded mid-sentence between pricing details and the endpoint URL, so an agent must extract it.

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 gives clear parameter-level usage guidance: plain GET for the newest chunk, ?before for older chunks, ?since for newer-than-watermark, and ?id for one official text. It also explains the payment flow (unpaid returns 402, paid returns JSON). But it provides no tool-selection guidance against siblings like search, get-one, get-page, or ticks, and 'Not a new SKU' is cryptic rather than an explicit routing instruction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations and no output schema, the description carries the full burden and discloses a lot: monetized access ($0.05/$0.02 USDC on Base to a specific address), HTTP 402 when unpaid, JSON returned after a valid X-PAYMENT, chunk/page/watermark behavior, and 'Not a new SKU' clarifying the shared payment door. It does not describe the JSON shape, but for a read-only GET the payment and error profile is unusually well covered.

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?

Three sentences with no filler, and the URL and price are front-loaded for quick recognition. The first sentence is overly dense — it crams the payment address, price, resource type, and a sub-pricing rule into one long clause — but every clause earns its place.

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 monetized, paginated, watermark-based tool with five optional parameters, no annotations, and no output schema, the description covers purpose, per-parameter pricing, payment flow, error behavior, and chunk semantics — far more than the typical sibling. The notable gaps are the JSON return shape and explicit sibling-routing guidance, but an agent can call and pay for this endpoint correctly based on the text alone.

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% with already-rich parameter descriptions (pricing embedded in id, 304/recordCount 0 semantics in since), so the baseline is 3. The description adds value by explaining the economics of the chunk model — newest chunk $0.05, older via ?before $0.05, watermark via ?since $0.05 — which helps an agent decide which parameter to set for a given retrieval need.

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 identifies the resource ('EPA FIFRA institution order / consent text') and the verb/URL (GET https://ticks.bnm.farm/fifra-orders), which distinguishes it from the 50+ sibling regulatory-document tools by agency and document type. However, the purpose statement is buried among payment mechanics — the opening sentence leads with the USDC price and wallet address rather than what the tool fetches.

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 gives a clear operational usage model: plain GET for the newest chunk, ?before for older chunks, ?since for newer-than-watermark, and ?id for a single official text. It never explicitly names an alternative tool or states when to prefer fifra-orders over a sibling, so cross-tool selection relies on the agent inferring from the name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does well: it discloses the payment requirement and price, the 402 for unpaid requests, that a valid X-PAYMENT causes the same URL to return JSON, and the chunking behavior. This is more behavioral disclosure than most tool descriptions provide.

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 compact and front-loaded with the URL and price, but it is a dense run-on with prices and endpoint modes packed into long sentences. It could be clearer with bullets or short sentences; still, there is 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 paid API with no output schema, the description explains payment, HTTP failure, and chunking, but it stops at 'returns JSON' without describing the response shape or error cases beyond 402. An agent would know how to pay and request, but not what to expect from the JSON payload.

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 meaningful semantics: it explains that ?id= returns one official text at $0.02, a plain GET is the newest chunk, ?before fetches older chunks, and ?since fetches newer-than-watermark at $0.05. Only the price names and payment semantics go beyond the schema.

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 identifies a concrete GET endpoint and states the resource: FinCEN institution consent-order text. It also explains the two retrieval modes (one official text via ?id= or chunks on a plain GET), which distinguishes it from sibling regulator-document tools like fdic-orders or cftc-orders.

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 gives clear context for when to use each request shape: plain GET for newest chunk, ?before for older chunks, ?since for newer-than-watermark, and ?id= for a single official text. It does not explicitly contrast this tool with sibling tools, so it misses the full when-not condition.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and does well: it reveals cost tiers for search, individual text, page, and import-alert table, and states that hits contain the door, id/page to buy, and fetchedAt/asOf. It also discloses that letter bodies and full import-alert table are not returned, so an agent knows exactly what to expect.

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 core purpose is front-loaded in the first sentence, and the long list of caches is justified by the need to define cross-door scope. The phrase 'Not a paid SKU' is slightly redundant with 'Free' and the pricing sentences that follow, but overall every sentence contributes useful 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 one-parameter search with no output schema, the description is quite complete: it explains result fields, pricing for follow-up retrieval, and special import-alert behavior. The only missing element would be concrete examples of q values or sorting, which are not essential for correct invocation.

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 only parameter q is documented in the schema with a clear description of accepted inputs (firm, FEI, CMS, etc.), and schema coverage is 100%. The tool description adds no additional parameter-level detail beyond the schema, so it stays at the baseline.

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 opens with 'Free cross-door search of official caches' and enumerates eleven specific cache types, naming the verb (search) and resource. This clearly differentiates it from single-door sibling tools like warning-letters or fmc-orders by emphasizing the cross-door scope and the metadata-only result structure.

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 states the search is free, lists what a hit contains, and notes that official text retrieval is a separate paid GET ?id= action. It also explicitly excludes letter bodies and the full import-alert table, signaling when not to use this tool. However, it doesn't name sibling tools as alternatives, so the routing relies on inference rather than explicit guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral disclosure burden. It clearly states the payment requirement ($0.05/$0.02 USDC on Base to a specific address), the unpaid HTTP 402 response, and that a valid X-PAYMENT makes the same URL return JSON. It does not mention rate limits or detailed response structure, but the critical paid-access behavior is transparent.

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 dense and mostly information-dense, but it is a single paragraph with semicolon-separated pricing rules and unexplained jargon like 'chunk', 'watermark', and 'SKU'. It is not bloated, but structure and plainer wording would improve clarity.

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 paid 5-parameter endpoint with no output schema and no annotations, the description covers payment, modes, and error behavior but does not explain the JSON response structure beyond saying it returns JSON. The schema provides hints like recordCount, but the missing return-shape detail is a noticeable gap.

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 input schema already provides rich descriptions for all 5 parameters, so the baseline is 3. The description adds the base URL, wallet address, and default pricing for a plain GET, but the semantic meanings of id, page, since, before, and x_payment are already well covered in the schema.

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 identifies the resource as FLRA Authority Decision text and the operation as a paid GET, with distinct modes for a single official text (?id), newest chunk, older chunk (?before), and newer-than-watermark (?since). It is clear about the subject matter but does not explicitly differentiate this tool from the many agency-specific sibling 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?

It gives explicit usage rules for each mode: plain GET for the newest chunk, ?id for one official text, ?before for older chunks, and ?since for newer texts, with per-mode pricing. It does not discuss when to prefer a sibling tool, but the parameter-level guidance is concrete and actionable.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the transparency burden and covers a lot: pricing, the 402 failure mode, the JSON response after payment, and the semantics of newest/older/watermark retrieval. It does not describe response fields or other error cases, but the essential behavioral traits an agent needs are disclosed.

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 dense and front-loaded with the endpoint and price, and almost every clause adds a distinct operational fact. It lacks formatting breaks, but at this length that is acceptable and there is 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 paid multi-mode GET with five optional parameters and no output schema, the description covers payment, error behavior, JSON return, and the conditions for id/before/since, while the schema covers page and x_payment details. The main omission is the exact JSON response shape, but the definition is otherwise sufficient for correct selection and invocation.

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, but the description adds meaningful context beyond the schema: it explains that a plain GET yields the newest chunk, attaches costs to specific parameter modes, and clarifies that id-based retrieval is the same door, not a new SKU. This enriches the already detailed parameter descriptions.

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 clearly identifies the resource as FMC Initial Decision / Commission Order text served from a paid GET endpoint, and enumerates the retrieval modes: official text via ?id=, newest chunk on a plain GET, and older/newer chunks via ?before and ?since. The FMC-specific naming helps distinguish it from the many sibling agency-order tools, though it does not explicitly name a sibling alternative.

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 gives explicit conditions for each invocation variant: plain GET for the newest chunk, ?id= for one official text, ?before for older chunks, and ?since for items newer than a watermark. It also states payment behavior, including HTTP 402 when unpaid and JSON after a valid X-PAYMENT, but it does not directly compare against sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations to rely on, the description carries the full behavioral burden and discloses the most important traits: per-request pricing in USDC, the payment recipient, the 402 failure mode when unpaid, and the fact that the same URL returns JSON after a valid X-PAYMENT. It also explains chunk semantics (newest, older, since-watermark). It omits details like rate limits or JSON structure, but the core payment-gated behavior is well covered.

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 dense and contains almost no filler; the endpoint and price are front-loaded, followed by the access modes and payment behavior. The sentence order is somewhat stream-of-consciousness, mixing mode descriptions with payment notes, but every sentence contributes meaningful 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 paid x402-style tool with five parameters, no annotations, and no output schema, the description covers the essential operational contract: how to request the newest chunk, an older chunk, a specific official text, or a since-watermark set, and what to expect before and after payment. It doesn't describe the JSON response shape or detailed error bodies, but an agent has enough context to invoke the tool correctly.

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 input schema already documents all five parameters at 100% coverage, so the description does not need to repeat definitions. It adds value beyond the schema by attaching costs to specific parameters (?id= is $0.02 versus $0.05 for chunk calls) and clarifying the payment flow for x_payment. This extra semantic layer helps an agent understand which parameters affect billing and behavior.

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 identifies the resource (FMSHRC decision/order text) and the operation through the GET URL and phrases like 'Newest chunk on a plain GET' and 'returns JSON'. It is clear that this tool serves FMSHRC orders specifically, and the FMSHRC path helps separate it from sibling agency tools. It lacks a single crisp verb phrase like 'Retrieve FMSHRC orders,' but the intent is unambiguous.

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 explicitly maps each invocation mode to its use: plain GET for the newest chunk, ?id= for one official text, ?before= for older chunks, and ?since= for texts newer than a watermark. It also states that unpaid requests return HTTP 402, which is important operational guidance. It does not name sibling tools as alternatives, but the mode-by-mode guidance is clear enough for correct selection within this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden, and it discloses important behaviors: unpaid calls return HTTP 402, a valid X-PAYMENT yields JSON, empty since-results return 304 or recordCount 0, and chunk ordering follows page/before/since. It omits response shape and other error cases, but the payment and pagination behavior is well covered.

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 dense and mostly informative, but it crams pricing, payment address, URL, and resource type into the opening clause. The closing phrase 'Not a new SKU' is cryptic and adds confusion rather than clarity. It is not bloated, but it lacks clean organization.

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 paid API tool with no output schema, the description explains how to pay, what happens when unpaid, what happens after payment, and how to navigate chunks via id/since/before. The main gap is the lack of any return-value shape beyond 'JSON', but an agent has enough context to invoke the tool correctly.

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. The description adds value beyond the schema by mapping each parameter to its cost, explaining the relationship between page, before, and since, and clarifying that X-PAYMENT is forwarded as a header. This earns an above-baseline score.

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 identifies the resource as 'FDA Form 483 observation bodies' and specifies a GET operation with multiple retrieval modes. It is clear enough to distinguish what data is being fetched, but it does not explicitly contrast itself with any of the 45 sibling regulatory-document tools, so it misses the top score.

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 provides detailed guidance on parameter combinations: plain GET gives the newest chunk, ?before gives older chunks, ?since gives newer-than-watermark text, and ?id fetches one official text. However, it never says when to choose this tool over alternatives such as gmp, warning-letters, or search, so the alternate-tool guidance is implied rather than explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does it well: it discloses payment requirements, exact costs, HTTP 402 for unpaid requests, JSON response after a valid X-PAYMENT, and chunk/watermark pagination behavior. It also notes empty results yield 304 or recordCount 0, which is genuinely useful behavioral detail.

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 dense but efficient, front-loading the URL and price before explaining retrieval modes and payment behavior. Almost every sentence earns its place; the only weak spot is the cryptic 'Not a new SKU' line, which adds little for an agent trying to invoke the tool correctly.

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 description covers the paid-access mechanics, parameter routing, error status, and output type, which is strong for a tool with no annotations and no output schema. However, it never describes the shape or fields of the returned JSON, and the meaning of 'chunk' is left somewhat implicit. Given the absent output schema, a bit more return-structure detail would make it complete.

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; the description adds value by attaching prices to id, before, since, and plain GET, and by explaining the paid-response flow around x_payment. It does not fully clarify page semantics or cost, but the schema already describes page as 1-based newest chunk, so the combined picture is solid.

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 identifies the resource and operation: a paid GET that returns FRB institution C&D / written-agreement / PCA text. It clearly names the endpoint and what kind of official texts are served. It does not explicitly differentiate this from sibling order-retrieval tools, so it misses the last bit of clarity.

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 gives internal routing guidance for id, before, since, and plain GET, but it never tells an agent when to choose frb-orders over sibling tools like fdic-orders, cfpb-orders, or ncua-orders. The phrase 'Not a new SKU' is billing/operational jargon rather than actionable tool-selection guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the behavioral burden and does disclose key traits: payment to a specific address, HTTP 402 when unpaid, X-PAYMENT header required for JSON, pricing per mode, and chunk/watermark behavior. It does not describe response structure beyond 'returns JSON', and 'Not a new SKU' is cryptic, but most operational behavior is transparent.

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 dense but mostly purposeful, packing endpoint, cost, payment flow, and pagination into four sentences. However, the opening mixes URL, price, and wallet address in one long breath, and the final 'Not a new SKU' is unexplained and likely to confuse rather than inform.

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 five parameters and no output schema, the description covers parameter behavior, payment requirements, and chunk pagination well. It lacks any indication of the JSON response shape, which makes it harder for an agent to know how to consume the result, and the SKU comment remains unresolved.

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 schema already describes all five parameters with 100% coverage, so the baseline is 3. The description adds pricing and clarifies some relationships ('Omit for the newest chunk', 'Same door, not a new SKU'), but it does not substantially extend the schema's meaning.

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 identifies the resource as 'USDA FSIS humane-handling enforcement letter text' and the endpoint as GET https://ticks.bnm.farm/fsis-humane, distinguishing it from sibling letter tools. The core purpose is clear, but the message is cluttered with pricing and payment details and lacks a crisp verb like 'fetch' or 'retrieve'.

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 explicit guidance about when to use this tool versus alternatives, and the large sibling list contains related tools like search, get-page, and other letter endpoints. The description only defines pagination/billing modes ('Newest chunk on a plain GET', 'older chunk if they ask'), not when this tool is the right choice.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full behavioral burden and it does well by disclosing payment requirements, HTTP 402 for unpaid requests, and the fact that the same URL returns JSON after a valid X-PAYMENT. It also communicates chunking behavior and empty-result behavior in the schema context, which is useful beyond a bare GET.

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 information-dense but somewhat run-on, mixing pricing, endpoint mechanics, payment behavior, and an odd 'Not a new SKU' phrase. It is front-loaded with the most important URL and cost information, but the phrasing is cryptic and could be cleaner.

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 paid GET tool with five parameters and no output schema, the description covers the critical operational context: payment flow, HTTP 402, parameter-specific costs, watermark behavior, and JSON response after payment. It leaves the JSON response shape undescribed, but enough is present for an agent to invoke the tool correctly.

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 a 3; the description adds extra meaning by attaching costs to each query mode and clarifying that these are not separate SKUs. It reinforces and extends the parameter semantics rather than merely repeating the schema.

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 a specific resource (FTC ALJ Decision / Commission Decision and Order text) and a concrete action (GET on a specific URL), so an agent can tell what the tool accesses. It does not explicitly contrast this tool with siblings like ftc-wl or cftc-orders, so it falls short of full differentiation.

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 gives clear operational guidance: plain GET returns the newest chunk, ?id returns one official text, ?before returns an older chunk, and ?since returns items newer than a watermark. It does not state when to choose a sibling tool, so it does not reach the full when-to-use-versus-alternatives standard.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and covers payment details, pricing per mode, the payment address, the 402 unpaid status, and the fact that the same URL returns JSON after a valid X-PAYMENT. It leaves some behavior unstated, such as response structure and how id interacts with pagination params, but for a paid API it discloses the critical auth and cost mechanics unusually well.

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 compact and front-loaded with the endpoint and price, but it is structured as dense fragments rather than clear prose. Every segment conveys information, yet phrases like 'Not a new SKU' are cryptic and the overall layout is not ideally organized for an agent to parse quickly.

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 paid 5-parameter API with no output schema or annotations, the description covers payment, pricing, authentication via X-PAYMENT, and the main retrieval/watermark modes. Gaps remain: the JSON response shape is not described, the interaction between id and page/since/before is not clarified, and the size or meaning of a 'chunk' is left implicit.

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 input schema already documents all five parameters with pricing and semantics (e.g., id: 'that one official text, $0.02', since: 'newer than this watermark, $0.05'). The main description adds little beyond what the schema provides, mostly reinforcing the chunking concept and the JSON-return-after-payment behavior, so it stays at the baseline for high schema coverage.

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 identifies a specific paid GET endpoint for FTC BCP warning-letter text and distinguishes the three access modes: single official text via ?id=, newest chunk via plain GET, older chunk via ?before=, and newer-than-watermark via ?since=. However, it reads more like a terse API spec than a declarative summary, and it does not explicitly differentiate from sibling tools such as warning-letters beyond the FTC BCP scope.

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 gives clear per-parameter usage guidance: use ?id= for one official text, plain GET for the newest chunk, ?before= for older chunks, and ?since= for newer-than-watermark results. It also states that unpaid requests return HTTP 402. It does not name sibling alternatives or exclusions, so the guidance is contextual but not comparative.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and it delivers: it discloses the paid nature and amounts, the payment address and currency, HTTP 402 on unpaid requests, the X-PAYMENT requirement, and the fact that a valid payment causes the same URL to return JSON. These are exactly the behavioral details an agent needs beyond the schema.

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 text is compact and mostly earns its place, but it is telegraphic and hard to parse: 'USDA FAS GAIN attaché report TEXT GET ?id= is one official text' and the semicolon chain make the structure dense. It lacks a clean front-loaded summary 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?

For a paid, paginated API with no output schema, the description plus rich parameter descriptions cover the key operational facts: pricing, chunk modes, failure status, and JSON behavior after payment. It could still be more complete about the response shape, but it is sufficient for selecting and invoking the endpoint correctly.

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 schema already documents every parameter in detail, including pricing and watermarks; the description repeats rather than adds much new semantic content. It adds the 'plain GET newest chunk' phrase, but that is also inferable from the schema's page/before descriptions.

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 a concrete resource (USDA FAS GAIN attaché report) and the operation (GETing official text or chunks), plus the payment URL. It does not explicitly contrast itself with sibling tools or say in plain language 'retrieve GAIN report text', so it stops short of full differentiation.

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 explains the operational modes: plain GET for newest chunk, ?before for older, ?since for newer, and ?id for a single official text. However, it gives no explicit guidance about when to select this tool over sibling tools such as get-one, get-page, or ticks, nor any exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses that the operation is paid (cost $0.02 / 20000 atomic), that it shares the same URL pattern (?id=), and that an unpaid request returns HTTP 402 with a specific prompt. These are important behavioral traits. However, it does not disclose what a successful call returns or any side effects, but for a paid get operation the disclosed error behavior is valuable.

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 short (three sentences) and contains no fluff, but it is not well-organized. It front-loads 'Paid' and then jumps to a potentially confusing 'Same URL ?id=' phrase before the 'Not a new SKU' clarification. The structure could be clearer by stating the core action first, but the length is acceptable.

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 parameters, no output schema, and no annotations, so the description must compensate. It explains the payment requirement and error behavior, but does not describe what the tool returns, how the URL is constructed beyond a vague reference, or how the door and x_payment parameters interact. The schema covers door options, but the description lacks critical usage context like what response to expect or prerequisites.

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 input schema has 100% coverage with each parameter described (id, door with enum list, x_payment). The description text adds no extra semantics beyond the schema; it mentions id and door but does not clarify usage or format beyond what schema already provides. Baseline 3 is appropriate as the schema does the heavy lifting.

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 states it is a 'Paid get-one on an extracted-body door' and mentions a URL with ?id=, implying retrieval of a single item by ID. However, the phrasing is cryptic and does not explicitly say 'gets a record by ID from a door' in plain terms. It differentiates from creating a new SKU but not from other retrieval tools like search or get-page, so its purpose is only partially clear.

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 is given on when to use this tool versus alternatives. It does not mention that this is for fetching a specific record after using search, nor does it exclude cases where get-page or search would be more appropriate. The only hint is 'Not a new SKU', but that does not clarify usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full behavioral burden. It discloses pricing ($0.05), failure mode (HTTP 402), page size (10 official texts), and pagination semantics. It adds meaningful behavior beyond what the schema covers, though it does not describe the response format.

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 compact and front-loaded, with each sentence covering a distinct operational aspect. It earns its place, though dense jargon like 'extracted-body door' and 'free-index cursor' requires the reader to decode domain-specific terms.

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 paid, paginated tool with no output schema and no annotations, the description covers the essential operational context: cost, payment requirement, pagination rules, and relationship to the door GET. It lacks explicit mention of authentication or the full response shape, but these are partially inferable from parameters and the '10 official texts' statement.

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%, giving baseline 3. The description adds value beyond the schema by explaining how parameters interact ('Omit before/page for the newest 10', 'before ... another $0.05') and clarifying the cursor semantics for 'since' and 'before'.

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 states the tool fetches a paid page of official texts from an extracted-body door, with the newest 10 as the default. It distinguishes itself from the door GET by noting 'Same URL' and 'Not a new SKU,' but the exact action ('get-page') is wrapped in jargon.

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 gives concrete usage conditions: omit before/page for the newest page, pass a free-index cursor for older pages, and use ?since= for newer-than. It also clarifies the relationship to the door GET and mentions HTTP 402 for unpaid calls, though it does not explicitly name alternative sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and discloses the unusual paid-access behavior: $0.05/$0.02 USDC on Base, HTTP 402 if unpaid, and JSON after a valid X-PAYMENT header. It also explains pagination-related behavior (newest chunk, older chunk, since watermark). However, it omits details about rate limits, error bodies, and exact response shape.

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 run-on that buries the resource definition amid pricing and payment details; it is not front-loaded with a clear summary. While each sentence carries information, the overall structure is disorganized and harder to scan than necessary.

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 description covers the most critical non-schema context: payment flow, unpaid response, pagination modes, and the id/$0.02 path. However, with no output schema, it leaves the response payload largely unspecified (only 'returns JSON' plus a recordCount mention in the schema), and it doesn't explain how 'page' fits the chunk model in the description.

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 baseline is 3. The description adds cost semantics for id ($0.02) and since/before ($0.05), and explains the chunk-based pagination logic beyond the schema's terse parameter notes. It does not describe the response format beyond JSON.

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 identifies a specific resource ('Health Canada Drug GMP report-card observation bodies') and makes clear this is a GET endpoint, but it lacks an explicit verb like 'retrieve' or 'list'. It does not differentiate itself from sibling tools such as gmp-md, though it hints at product lineage with 'Not a new SKU.'

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 is given on when to choose this tool over alternatives; the only comparative statement, 'Not a new SKU', refers to product identity, not selection criteria. The description does explain operational usage patterns (plain GET, ?id, ?before, ?since), but stops short of when-to-use vs alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully carries the safety/behavior burden and does so: it discloses payment requirement and cost, per-mode pricing, HTTP 402 when unpaid, that the same URL returns JSON after valid X-PAYMENT, and pagination semantics. This is unusually transparent for a tool with no behavior annotations.

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 compact and front-loads the endpoint and payment requirement before usage modes. However, the trailing 'Not a new SKU' and scattered pricing tokens add noise and are less useful to an agent than the schema already provides.

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 paid, paginated GET tool with no output schema, the description covers endpoint, payment, error behavior, response type, and query-mode semantics. The main omission is the exact shape of the returned JSON, but the response body is implied to be official text/chunks and the x402 payment mechanism is referenced.

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?

Input-schema descriptions cover 100% of parameters already (id, page, since, before, x_payment) and are themselves detailed, so the baseline is 3. The tool description adds confirming context about pricing/pagination but no major new parameter-level meaning beyond the schema.

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 a specific resource ('Health Canada medical-device report-card observation bodies') and the HTTP verb ('GET'), and distinguishes query modes (?id official text, plain newest chunk, ?before older, ?since newer). It is not a tautology and is more specific than a generic fetch, but it never names a sibling tool, so the differentiation from gmp is left implicit.

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?

Clear usage contexts are given for each mode: id for one official text, plain GET for newest chunk, before for older chunk, since for newer-than-watermark. It lacks an explicit when-not-to-use or comparison with sibling tools like gmp, so it misses exclusions/alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It transparently states that the endpoint costs $0.05 USDC, returns HTTP 402 when unpaid, and returns JSON after a valid X-PAYMENT. It does not describe response shape or persistence, but the most decision-relevant behaviors are disclosed.

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 short and front-loads the URL and cost, but it is a single dense paragraph with a confusing trailing phrase 'Not a new SKU.' That phrase adds no agent-useful information, and the punctuation makes the payment behavior harder to parse than necessary.

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 payment flow, 402 failure mode, and JSON success response are covered, which is good for a paid endpoint with one optional parameter and no annotations. However, there is no output schema and the description does not clarify what the JSON contains or how it relates to the 'report PDFs' mentioned, leaving a meaningful gap.

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 schema already covers the single parameter x_payment with 100% description coverage, so the baseline is 3. The description adds context about X-PAYMENT being tied to payment validity and 402 behavior, but does not materially enrich the parameter's meaning beyond the schema.

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 identifies the resource (HHS OIG audit and evaluation report PDFs) and the HTTP method (GET), making the tool's basic purpose reasonably clear. It does not use an explicit verb like 'fetch' or 'retrieve', and the phrase 'Not a new SKU' adds noise, but the endpoint and resource are identifiable.

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 explains the payment requirement and the behavior when unpaid (HTTP 402) versus paid (JSON), which gives an agent some operational usage guidance. However, it never states when to choose this tool over sibling tools or when not to use it, leaving alternative selection to inference from the tool name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden and does so well: it discloses the payment requirement, exact cost per request, the recipient address, HTTP 402 for unpaid requests, and the fact that the same URL returns JSON after a valid X-PAYMENT. It also explains chunking behavior and that id is not a separate SKU.

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 dense and front-loaded with the endpoint and price, and every sentence contributes meaningful information. It is slightly run-on and terse, but there is no filler or repetition; the compact style is acceptable for a payment-gated endpoint.

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 the tool's payment gate, multiple chunking modes, and HTTP error behavior, the description plus the fully documented schema cover what an agent needs to invoke it correctly. The main gap is the unspecified JSON response shape: the description says 'returns JSON' but does not describe fields, which matters more because there is no output schema.

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, but the description adds real meaning by mapping each access mode to pricing and behavior: id costs $0.02 and returns one official text, while page/before/since cost $0.05 and define chunk boundaries. This goes beyond the schema's parameter labels.

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 a specific verb (GET), a concrete resource (ICO Monetary Penalty Notice text), and a distinct endpoint URL. It also separates access modes (official text by id, newest chunk, older chunk, newer-than-watermark), which makes the tool distinguishable from siblings like get-one or search without opening their schemas.

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 gives clear operational guidance: a plain GET returns the newest chunk, ?before fetches an older chunk, ?since retrieves texts newer than a watermark, and ?id returns one official text. It does not explicitly compare against sibling tools, but 'Not a new SKU' and the resource-specific naming imply when this tool is relevant.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the behavioral disclosure burden and does so well: it states unpaid calls return HTTP 402, valid X-PAYMENT returns JSON, unchanged snapshots return 304 via If-None-Match or since, and it includes the payment address and amount. It does not describe response contents or other error cases, but the key transactional behavior is explicit.

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 dense but mostly purposeful: URL, pricing, payment destination, dataset, conditional behavior, and payment outcome are all included. The closing phrase 'Not a new SKU' is ambiguous and slightly weakens clarity, but the overall block remains compact and information-rich.

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 paid single-resource endpoint with no output schema and no annotations, the description covers the essential invocation context: how to pay, what happens before and after payment, and how conditional headers avoid re-billing. It could be more explicit about the JSON response shape, but an agent has enough to call and interpret the main outcomes.

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 input schema already documents all three parameters thoroughly, including the 304 behavior and ETag reuse. The description reinforces the conditional-request usage but adds little beyond what the schema provides, so the baseline 3 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 clearly identifies a specific resource: a paid GET endpoint returning the FDA Import Alerts / DWPE current table. It is specific about the verb, URL, and dataset, though it does not explicitly distinguish itself from the many sibling regulatory-data 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?

No guidance is given on when to choose this tool over alternatives like search, get-page, or other dataset-specific endpoints. The description explains the payment and conditional-request workflow, but not the decision context or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Since no annotations are present, the description carries the full transparency burden and does so well: it discloses the exact price, the payment recipient, the HTTP 402 behavior when unpaid, and the fact that the same URL returns JSON after a valid X-PAYMENT. This is unusually explicit for a paid endpoint.

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 compact and front-loaded with the URL, price, and payment behavior. The final sentence 'Not a new SKU.' is cryptic and adds limited actionable guidance, but the overall description remains tight and readable.

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 description gives essential endpoint and payment mechanics, which is good for a simple one-parameter tool. However, there is no output schema and no description of what the returned JSON represents, and the sibling tools suggest regional/variant options that are not differentiated here, leaving a meaningful completeness gap.

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 input schema already fully documents x_payment as an optional x402 X-PAYMENT value forwarded as a header, giving the parameter complete schema coverage. The tool description adds little beyond implying that a valid X-PAYMENT unlocks the JSON response, so the baseline of 3 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 clearly identifies the operation as a GET to a specific URL and explains the payment-gated behavior: unpaid requests yield HTTP 402 and paid requests return JSON. However, it never states what content the JSON contains or how this endpoint differs from siblings like mariners-d11/d7/d8, so it falls short of full clarity.

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 provides practical usage context: a valid X-PAYMENT is required to get JSON and unpaid calls return 402. It does not explicitly explain when to choose this tool over the similar mariners-d11/d7/d8 variants or when not to use it, leaving the selection logic mostly implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Describes payment requirement, HTTP 402 on non-payment, and JSON response after payment. However, it does not describe the actual data content or any side effects. No contradiction with annotations as none are provided.

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 relatively short but includes cryptic phrasing like 'USCG D1 / Northeast LNM Unpaid' and 'Not a new SKU', which may confuse rather than clarify. It is a single block of text without clear structure.

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?

Lacks information about the returned JSON structure, data fields, or purpose. An agent would not know how to interpret the response. Payment mechanics are explained, but the core functionality 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?

The only parameter x_payment is well-described in the schema as an X-PAYMENT header value. The description does not add further details, but schema coverage is 100%, so the baseline score of 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?

The description mentions USCG D1 / Northeast LNM Unpaid but does not clearly state what data the endpoint returns. The verb 'GET' is used, but the resource's purpose remains vague and ambiguous.

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 is provided on when to use this tool versus sibling tools like mariners or mariners-d11. The note 'Not a new SKU' is ambiguous and does not clarify selection criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full behavioral burden, and it discloses the critical behaviors: exact USDC cost, recipient address, HTTP 402 for unpaid access, and JSON on success after a valid X-PAYMENT. It does not explain how to obtain the X-PAYMENT value, but it is still substantially transparent.

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 terse and front-loaded with the URL and payment details, with no redundant filler. The final 'Not a new SKU' note is cryptic and unexplained, which keeps it from a perfect score.

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 tool with one optional parameter and no annotations or output schema, the description covers the operational essentials: URL, payment target and amount, failure status, and success result type. It still leaves the exact JSON content and the process for obtaining a valid X-PAYMENT unspecified, so it is not fully complete.

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 input schema already documents x_payment clearly as an optional x402 value forwarded as the X-PAYMENT header, so the baseline is 3. The description adds that the value must be 'valid' for JSON to be returned, but it does not add format, provenance, or acquisition details beyond the schema.

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 identifies an exact HTTP GET endpoint and a concrete data scope (USCG D11 / Southwest LNM), and says a valid X-PAYMENT makes the URL return JSON. It does not explicitly say what the returned JSON contains or how this differs from mariners-d7/d8, so it is clear but not fully differentiated.

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 payment/402 workflow implies when the tool can be used: an unpaid request returns 402 and a paid request returns JSON. The 'USCG D11 / Southwest LNM' label gives context, but there is no explicit when-to-use or when-not-to-use guidance relative to sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the transparency burden and does disclose key behaviors: returns HTTP 402 when unpaid, requires a valid X-PAYMENT header, and returns JSON after payment. It does not mention side effects or safety, but the GET verb and payment-gated model are sufficiently described.

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 brief and front-loads the endpoint and cost, with payment and response behavior in clear sequence. The final sentence 'Not a new SKU' is unnecessary and detracts slightly from overall conciseness.

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 and the description only says 'returns JSON', providing no information about the response structure, fields, or pagination. It also does not explain what 'USCG D14 / Pacific LNM' data actually represents, leaving significant gaps for a caller trying to use the tool correctly.

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 only parameter, x_payment, is fully described in the input schema as an optional X-PAYMENT header value to forward. The description reinforces the payment-header behavior but does not add meaningful new parameter semantics beyond the schema, so the baseline score of 3 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 identifies the endpoint as a paid GET for 'USCG D14 / Pacific LNM' and states that after valid payment it returns JSON, giving a reasonably clear sense of the tool's purpose. However, it does not explicitly say what data the JSON contains, and the odd phrase 'Not a new SKU' adds confusion rather than clarity.

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 say when to choose this tool over its many mariners-d* siblings, nor does it explain the intended use case for 'USCG D14 / Pacific LNM'. It only describes the payment behavior, not the selection criteria or context for using this specific endpoint.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden. It discloses that unpaid requests return HTTP 402 and that a valid X-PAYMENT yields JSON, which is useful. However, it does not mention that it is a read-only GET, any rate limits, or what happens on other errors. The cryptic 'Not a new SKU' adds confusion rather than clarity.

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 run-on sentence with multiple clauses, including payment details, endpoint, response condition, and a confusing note. It is compact but not well-structured; the information could be presented more clearly with separation of payment requirements from tool behavior.

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 paid API endpoint, the description lacks essential details: how to obtain payment, what the JSON contains, whether there are limits, and how this differs from the many sibling mariners tools. The absence of an output schema makes it even more critical to describe the response, which is not done. It is inadequate for an agent to fully understand and use this tool correctly.

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 x_payment is fully described in the schema with a clear explanation that it is forwarded as a header. The description reinforces that a valid X-PAYMENT is required for JSON, adding context about its necessity, but it does not add new meaning beyond the schema's description, so a baseline of 3 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 states it is a GET endpoint that returns JSON after payment, and mentions 'USCG D17 / Alaska LNM' which implies a specific data domain, but it does not clearly state the resource or what data is retrieved. It is distinguishable from siblings by the D17 suffix, but the purpose is more about the payment mechanism than the action itself.

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 compare this tool to any of the many mariners-* siblings. It implies usage for D17 via the name and 'USCG D17 / Alaska LNM', but it does not explicitly say when to use this versus other mariners tools, nor does it mention prerequisites like having a payment mechanism set up beyond the X-PAYMENT header.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

It states that unpaid requests return HTTP 402 and that a valid X-PAYMENT yields JSON, revealing the payment gating and response format. However, it does not describe data side effects, rate limits, or other error conditions, leaving some behavioral aspects undisclosed.

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 short and avoids unnecessary verbosity, but it includes cryptic phrases like 'USCG D5' and 'Not a new SKU' that reduce clarity. It is concise but sacrifices comprehensibility.

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 description lacks context about the data returned, the meaning of 'USCG D5 / Mid-Atlantic LNM', and the tool's overall purpose. It also omits any output schema or examples, leaving substantial gaps for an agent to understand the tool's functionality.

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 only parameter, x_payment, is described in the schema as an optional string forwarded to the paid GET as a header. The main description also references 'valid X-PAYMENT', making the parameter's role clear, though additional details such as expected format or validity conditions are absent.

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 provides a URL and payment details but does not clearly state what the tool does. References to 'USCG D5 / Mid-Atlantic LNM' and 'Not a new SKU' are cryptic without explanation, leaving the core function ambiguous.

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 mentions payment and header requirements but gives no guidance on when to select this tool over sibling tools like mariners-d1 or d7. No selection criteria or use cases are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the behavioral burden and does a solid job: it discloses the paywall behavior (HTTP 402 when unpaid), the payment requirement ($0.05 USDC on Base), and that the same URL returns JSON after a valid X-PAYMENT. It does not describe response contents or failure modes beyond 402, but the core payment-gated behavior is clear.

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 compact and front-loaded with the endpoint and payment requirement. Every sentence conveys operational information, though 'Not a new SKU' is somewhat cryptic and could be clarified or removed.

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 simple one-parameter, no-output-schema tool, and the description provides the essential context: payment amount, recipient, HTTP behavior, and response type. It lacks detail on the JSON structure, but for a low-complexity paid endpoint this is a reasonably complete picture.

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% and the single x_payment parameter is already well documented as an optional X-PAYMENT header value. The description reinforces that a valid X-PAYMENT unlocks JSON but adds little meaning beyond the schema.

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 identifies a specific HTTP GET endpoint and resource ('USCG D7 / Southeast LNM') and indicates it returns JSON after payment. The 'mariners-d7' naming plus 'USCG D7' distinguishes it from sibling tools like mariners-d8 and mariners-d11, though the description does not explicitly name those alternatives.

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 is given for when to use this tool versus the many sibling tools. The phrase 'Not a new SKU' hints at product positioning but does not help an agent decide between mariners-d7 and related mariners tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does well: it states the payment amount, recipient address, the unpaid 402 response, and the JSON success response. It does not detail rate limits or payload structure, but the essential paid-GET behavior is transparent.

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 key facts are packed compactly and the URL is front-loaded, but the description is telegraphic and the final phrase 'Not a new SKU.' is cryptic and does not clearly earn its place. It could be clearer without losing conciseness.

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-optional-parameter paid endpoint with no output schema and no annotations, this description covers the essential operational context: URL, price, payee, failure mode, success format, and the X-PAYMENT precondition. The remaining gaps, such as how to obtain a valid payment token and JSON field details, are mino.

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 input schema already fully documents x_payment as an optional x402 value forwarded as the X-PAYMENT header, giving 100% schema coverage. The description's mention of 'a valid X-PAYMENT' adds no meaningful parameter-level detail beyond that baseline.

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 clearly identifies the action as a GET to a specific paid endpoint for 'USCG D8 / Gulf LNM', with explicit cost and recipient. It distinguishes the resource enough from the many mariners-style siblings, though it does not explicitly compare them.

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 resource name and payment flow imply when this tool should be used, and the 402 behavior sets an expectation for unpaid calls. However, there is no explicit guidance on when to choose this over mariners-d7, mariners-d11, or other related mariners tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the transparency burden and does well by disclosing the $0.05 USDC payment requirement, the 402 response when unpaid, and JSON after a valid X-PAYMENT. It is slightly marred by the cryptic 'Not a new SKU' sentence but otherwise reveals key runtime behavior.

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 short but grammatically choppy and includes cryptic fragments such as 'USCG D9 / Great Lakes LNM Unpaid returns HTTP 402' and 'Not a new SKU.' It front-loads the URL and payment detail, but clarity suffers from unconventional punctuation and unclear phrasing.

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 description explains how to obtain JSON (pay and pass X-PAYMENT) and what happens if unpaid, but it gives no details about the response structure, data fields, or other possible error codes. It is workable for a simple paid GET but not fully contextual.

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 only parameter, x_payment, is described in the schema as an optional x402 X-PAYMENT value forwarded as a header, and the tool description reinforces how it unlocks the response. This fully explains the parameter's meaning and usage, though the tool description adds little beyond the schema.

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 specifies a GET endpoint for USCG D9 / Great Lakes Local Notice to Mariners data and includes a payment condition. It identifies the resource via 'USCG D9 / Great Lakes LNM' but does not explicitly state that the tool returns LNM content or contrast it with sibling district 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?

No explicit guidance is given for when to use this tool over sibling mariners-d1/d5/d7/d8/d11/d14/d17 tools. The resource label 'USCG D9 / Great Lakes LNM' implies a geographic district, but the description does not state selection criteria, exclusions, or alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and does so thoroughly: it discloses the $0.05 USDC payment destination, the $0.02 official-text price, HTTP 402 when unpaid, JSON after a valid X-PAYMENT, and pagination/watermark behavior. These are exactly the non-obvious traits an agent needs before calling a paid endpoint.

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 dense but compact; nearly every clause carries pricing, mode, or behavioral information. It is front-loaded with the endpoint and payment address. The cryptic 'Not a new SKU' and the lack of any formatting keep it from a perfect score.

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 paid, parameterized endpoint with no output schema, the description and schema together cover endpoint, pricing, payment address, X-PAYMENT, pagination modes, watermark behavior, and HTTP status codes. The main gap is the absence of an example or a precise statement of the JSON response fields, though the schema hints at recordCount.

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 schema already provides 100% rich parameter coverage, so the baseline is 3. The description adds value beyond the schema by explicitly mapping parameter choices to costs and response modes, and by naming the payment address and X-PAYMENT success outcome. This compensates for any ambiguity in the schema's brief x_payment note.

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 opens with the exact GET endpoint and identifies the resource as NCUA institution consent C&D text. It further distinguishes behavior: a plain GET returns the newest chunk and ?id returns one official text, so an agent can tell this is a retrieval tool for NCUA orders among many agency-order siblings.

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 gives explicit operational guidance: plain GET for the newest chunk, ?before for an older chunk, ?since for newer-than-watermark content, and ?id for one official text. It also states the payment and HTTP 402 behavior. It does not explicitly name sibling alternatives, but the NCUA-specific scope and query-mode rules provide clear usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 discloses the payment gate, HTTP 402 behavior, X-PAYMENT header requirement, and the fact that the same URL returns JSON after payment. It does not explicitly state read-only/idempotent behavior, but the GET-only design and payment-before-response model make the side-effect profile reasonably clear.

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 dense and every clause carries useful information, but it is not well front-loaded: it begins with the payment address and pricing before stating the core purpose. The heavy use of semicolons and price annotations makes it harder to parse quickly, even though there is no filler or repetition.

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 paid GET tool with no output schema, the description covers essentially all caller-relevant context: available request modes, pricing, payment authorization, failure behavior, and response type. It does not describe the JSON shape, but the schema covers the parameters thoroughly and the description gives enough to successfully construct and pay for a request.

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 schema already fully documents all five parameters. The description adds useful context about pricing and which request mode maps to each parameter, but it does not materially expand the semantic meaning beyond what the input schema already provides. Baseline 3 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 clearly states this tool serves NLRB published Board Decision text from a specific paid GET endpointmente. It distinguishes the id-based official text lookup from chunked newest/older/newer-than-watermark requests, which gives an agent a concrete picture of what the tool does. It does not explicitly differentiate from sibling tools, but the NLRB resource and the API variant semantics are specific.

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 gives explicit usage variants: plain GET for newest chunk, ?id= for one official text, ?before= for older chunks, and ?since= for newer-than-watermark. It also states that unpaid requests return HTTP 402 and that a valid X-PAYMENT is required before JSON is returned. This is strong operational guidance, though it does not compare against sibling tools directly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description carries the full behavioral disclosure burden. It explicitly discloses payment requirements, the HTTP 402 response when unpaid, the JSON response after a valid X-PAYMENT, and the 304/recordCount 0 behavior for empty since results. This is candid and detailed, though it does not address any potential side effects, which are presumably none for a read-only GET.

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 dense paragraph that packs endpoint, pricing, query modes, and error behavior into a few sentences. While the semicolon-heavy structure is a bit run-on, every clause provides necessary information and there is no extraneous 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?

The tool has five optional parameters, no output schema, and no annotations, which puts a premium on the description to explain both invocation and response. It thoroughly covers invocation and payment but only vaguely mentions 'returns JSON' without describing the response shape or fields. An agent calling this tool might not know what to do with the JSON without further documentation.

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 input schema already covers 100% of parameters with detailed descriptions, including pricing and semantics, so the baseline is 3. The main description adds a conceptual framing (e.g., 'plain GET' is the newest chunk, id is one official text) but mostly paraphrases what the schema already provides, so it does not substantially raise the score.

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 specific resource (NMB representation determination text) and the operation (HTTP GET), which clearly distinguishes this tool from its many sibling tools covering other agencies. The pricing and endpoint details reinforce the purpose even though they are presented in a dense style.

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 provides detailed guidance on which query parameter to use for different retrieval needs (specific id, newest chunk, older chunk, watermark filter) and their associated costs. However, it does not explicitly compare this tool to sibling tools or state conditions when one should avoid this tool; the differentiation from siblings is only implicit through the unique resource name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 key behaviors: payment is required, unpaid returns 402, after X-PAYMENT the same URL returns JSON, and empty new sets return 304 or recordCount 0. It omits some details like parameter conflicts and other error codes, but on balance it is transparent about the unusual paid API flow.

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 text is compact and front-loaded with the URL and price, but it is a dense run-on of dash-separated clauses that require careful parsing. No words are wasted, yet the structure sacrifices readability for brevity.

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 description adequately covers payment, pricing, and pagination semantics for a paid endpoint. However, there is no output schema and the description only says 'returns JSON' without detailing the response structure, nor does it explain how to combine parameters or obtain a valid X-PAYMENT.

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 each parameter already has a detailed description including pricing and behavior. The tool description reinforces this with the pricing model but doesn't clarify interactions between parameters (e.g., id combined with since). Baseline 3 is appropriate because the schema does the heavy lifting.

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 identifies the resource (EPA individual NPDES permit text) and the operations (plain GET, ?id=, ?before, ?since), and even distinguishes it from a new SKU. However, it never uses an explicit verb like 'retrieves' and the message is conveyed through pricing and URL patterns rather than a straightforward statement.

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 explains when to use each parameter variant (newest chunk, older chunk, since watermark) and states the payment prerequisite (HTTP 402 for unpaid). It doesn't mention alternatives among sibling tools or conditions for choosing this over another endpoint, so usage guidance is partial.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure and does so thoroughly. It reveals that unpaid requests return HTTP 402, that a valid X-PAYMENT is required, that the same URL then returns JSON, and that pagination works via chunk markers (newest/older/since). It also discloses pricing per call and the payment destination. This is substantial transparency beyond a simple 'retrieve document' statement.

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 front-loaded with the URL and price, and each of the six sentences conveys a distinct fact (payment, scope, pagination, error behavior). It is relatively compact given the amount of information. However, the phrase 'Not a new SKU.' adds jargon and is somewhat redundant with the schema's 'same door, not a new SKU', slightly undermining clarity.

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 description covers payment, error codes, pagination modes, and the fact that a successful response is JSON. However, there is no output schema, and the description only says 'returns JSON' without describing the JSON structure or fields. An agent would not know how to parse the response to extract the actual decision text, which is a meaningful gap for a document-retrieval tool. More detail about the return shape would be needed for full completeness.

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 each parameter already has a detailed description including pricing and pagination semantics (e.g., id is $0.02, before is 'another $0.05'). The tool description adds little beyond reinforcing the ?id= and ?since/?before patterns already in the schema. Since the schema does the heavy lifting, the baseline 3 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 explicitly identifies the resource as 'DOL OALJ / BALCA / ARB Decision and Order text' and the action as a GET that can retrieve a specific official text via ?id=. This clearly distinguishes it from the many sibling agency-decision tools (e.g., epa-alj, fmshrc-orders) by naming the exact collection it serves. The core purpose is stated with a specific verb (GET) and a specific resource.

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 provides clear context for when to use this tool: it is for DOL OALJ / BALCA / ARB decisions, which is implicit guidance for selecting among siblings. It also details several usage modes (plain GET for newest chunk, ?before for older, ?since for newer than a watermark, ?id for a single text) and the payment requirement. However, it does not explicitly name alternatives or state when NOT to use it, so it falls short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly discloses the $0.02/$0.05 pricing, the USDC Base payment address, HTTP 402 for unpaid requests, and JSON responses after a valid X-PAYMENT. This gives an agent a clear model of the tool's real-world behavior.

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 dense and information-rich, with nearly every clause earning its place by adding pricing, pagination, or failure behavior. However, it reads as a run-on block and does not cleanly front-load the core purpose before payment details, which keeps it from being perfectly structured.

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 paid, paginated text retrieval tool with no output schema, the description covers payment, price tiers, pagination modes, error behavior, and response format. Minor gaps remain, such as how page relates to before/since pricing and how an agent obtains an X-PAYMENT value, but the core context needed to call the tool is present.

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 schema already explains id, page, since, before, and x_payment in detail. The description adds pricing and response behavior, but does not materially improve parameter semantics beyond what the schema states, so the baseline score of 3 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 clearly identifies the tool as serving OCC institution C&D / consent-order text via a GET endpoint, naming the specific resource. It does not explicitly distinguish itself from sibling tools, but the OCC-specific scope makes the purpose reasonably clear.

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 gives concrete usage guidance: a plain GET returns the newest chunk, ?before returns an older chunk, ?since returns newer-than-watermark content, and ?id retrieves one official text. It does not compare with sibling tools or state when not to use it, so it stops short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the behavioral disclosure burden and does it well: it explicitly states unpaid requests return HTTP 402, valid X-PAYMENT unlocks JSON, empty since-sets return 304 or recordCount 0, and different query modes have different costs. The 'Not a new SKU' phrasing is confusing, but the core operational behaviors are disclosed.

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 short and information-dense, which is good, but it front-loads pricing and a payment address before stating what the tool does. The repeated 'same URL'/SKU phrasing and terse parentheticals make the structure somewhat noisy and harder to parse.

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 is operationally complex due to payment gating, watermark pagination, and id-specific pricing, and the description covers the critical parts: payment cost and address, HTTP 402, X-PAYMENT header behavior, paging semantics, and JSON return. It does not describe the JSON shape beyond 'returns JSON' and 'recordCount 0', but with no output schema, the essential invocation context is largely complete.

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 schema already documents all five parameters and the baseline is 3. The description reinforces the meanings of id, since, before, and page with chunk/watermark language, but it mainly restates what the schema already says. Pricing details add context but do not significantly deepen parameter semantics.

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 a specific resource, OFAC institution enforcement-release texts, and a concrete retrieval action via GET, including id-based single-text retrieval. It does not explicitly distinguish itself from the many sibling order/report tools, but the OFAC framing and endpoint make the resource unambiguous.

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 gives clear internal usage modes: a plain GET returns the newest chunk, ?before fetches older chunks, ?since fetches newer-than-watermark items, and ?id buys one official text. However, it does not explain when to prefer ofac-orders over sibling tools such as bis-orders or cftc-orders, so cross-tool selection guidance is essentially absent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the behavioral burden and does disclose key traits: unpaid requests return HTTP 402, a valid X-PAYMENT makes the same URL return JSON, and empty new sets return 304 or recordCount 0. It also exposes the payment requirement and distinguishes the id path from chunk paths. It does not describe chunk size, rate limits, or detailed output structure, but it is informative for a paid read-only endpoint.

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 compact, but the opening mixes the URL, payment recipient, amount, and resource purpose, making the actual purpose less discoverable. The payment and pricing details could be separated or abbreviated; the structure is functional but not front-loaded around what the tool retrieves.

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 description covers the endpoint, payment obligation, X-PAYMENT behavior, error code, and chunk navigation, which is enough for a first call. However, there is no output schema, and the description only says 'returns JSON' and implies recordCount, leaving the response shape and the meaning of 'chunk' under-specified. For a five-parameter tool with no annotations, that is a meaningful gap.

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?

All five parameters already have descriptions in the input schema, so the description does not need to re-explain them. It adds pricing context ($0.02 for id, $0.05 for chunks) and reinforces that page is ignored when since/before is set, but it does not meaningfully expand the semantic meaning beyond the schema.

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 identifies the resource as 'Ofgem enforcement-notice text' and clarifies retrieval semantics: a plain GET returns the newest chunk, ?id= returns one official text, and ?before/?since navigate chunks. It does not explicitly differentiate itself from similarly named siblings such as ofwat-enforcement or orr-enforcement, so it stops short of full sibling differentiation.

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 gives explicit parameter-selection guidance: plain GET for the newest chunk, ?before for older chunks, ?since for newer-than-watermark content, and ?id for a single official text. However, it never states when to choose this tool over sibling enforcement tools or when not to use it, leaving tool selection mostly to inference from the name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.