red-web-utils

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

With no annotations, the description carries the full burden and does meaningful work: it discloses pay-per-call pricing ($0.001 USDC on Base), the payment protocol (x402/MPP) and the concrete failure mode (a 402 challenge on unpaid calls). It also states the return format (plain text), though 'first section' is left unexplained and no rate limits or other error modes are 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 tight sentences with no repetition: what it does and its identifier format first, then the return shape, then cost/auth constraints. Every sentence adds information an agent needs before calling.

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 single-parameter, no-output-schema tool, this covers the essentials: input format, return type, and the non-obvious payment precondition that would otherwise cause silent failures. Only the ambiguous 'first section' phrase 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 coverage is nominally 100%, but the schema's own text for `path` is merely 'required', so the description's illustrative format 'uksc/2024/1' is the actual source of meaning about what the value looks like. It stops short of stating where paths come from or what a malformed path does.

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?

Names a specific verb (fetch) and a precisely scoped resource (text of a UK court judgment) keyed to a Find Case Law path, with a concrete example ('uksc/2024/1'). This distinguishes it cleanly from siblings like caselaw_search (discovery), caselaw_us (different jurisdiction) and legislation_search (different source type).

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 example path implies the caller must first resolve an identifier, and the UK framing implies when this is the right caselaw tool, but it never explicitly says to use caselaw_search to obtain a path or states when to prefer caselaw_us. Usage is inferable rather than stated.

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 exist, so the description carries the full burden and does disclose genuinely non-obvious behavior: pay-per-call pricing, the USDC/Base payment rail, and that unpaid calls return a 402 challenge. It also enumerates the returned fields. It falls short of stating result caps, pagination, or rate limits, which matter for a search 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?

Three compact sentences: scope first, then return shape, then cost/payment behavior. Every sentence contributes information an agent would otherwise have to guess at.

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 and no annotations, the description covers source, jurisdiction, date coverage, return fields, pricing model and the failure mode on non-payment. The main omission is result-set size/pagination, which an agent needs to plan multi-step retrieval.

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?

There is a single required parameter with 100% schema coverage, though the schema text is only the word 'required', so it describes nothing meaningful. The description adds no query syntax, boolean/phrase support, or court-filter guidance, 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?

States a specific verb (Search) against a specific resource (UK court judgments), naming the underlying source (Find Case Law, The National Archives), covered courts and the 2001-present range. The UK jurisdiction scope implicitly separates it from caselaw_us and the search/list framing separates it from caselaw_fetch.

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?

By saying it returns case names, courts, dates and links, it hints that this is the discovery step before caselaw_fetch retrieves the full judgment, but that routing is never stated explicitly. No exclusions or prerequisites (e.g., minimum query length, jurisdiction limits) are given, leaving usage 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, the description carries the full burden and does well: it discloses the pay-per-call cost ($0.001 USDC on Base), the payment protocol and the exact failure mode an unpaid call produces (a 402 challenge). It also enumerates the return payload (names, courts, dates, citations, snippets, links). It omits pagination behavior, result caps, and whether a failed/402 call is still billed.

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, zero waste, correctly front-loaded: what it searches, what comes back, what it costs and how payment surfaces. The pricing sentence is unusual but earns its place because a 402 response would otherwise look like an error.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema exists, and the description compensates by listing returned fields, which is good. But for a search tool with a same-named sibling and no annotations, it should cover pagination/result limits and query/court parameter conventions; those gaps leave an agent unable to call it correctly or choose it confidently.

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 two parameters are already documented structurally, and the baseline is 3. The description adds no semantics for 'q' (query syntax, boolean support, natural language vs terms) or 'court' (expected court identifier format), which are the two things an agent would most likely get wrong.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Search US case law') plus the underlying data source (CourtListener / Free Law Project), which tells the agent what corpus is being hit. It does not distinguish itself from the sibling 'caselaw_search', whose name implies an overlapping function, so the agent cannot tell the two apart from the description alone.

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 never says when to use this tool rather than the near-identically named siblings caselaw_search or caselaw_fetch, nor does it give any exclusions or prerequisites. The only decision-relevant hint is the per-call price, which an agent could use to prefer a free alternative, but that inference is left 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?

With no annotations, the description carries the full burden and does well: it discloses pay-per-call pricing ($0.002 USDC on Base), the x402/MPP payment flow, and that unpaid calls return a 402 challenge. It also scopes results to the collected dataset, though it does not discuss rate limits, pagination, or read-only status explicitly.

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, each carrying distinct information: purpose, use case, and payment behavior. The core capability is front-loaded with 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 one-parameter read tool with no output schema, the description explains the return shape (pairs, first/last seen, counts), the dataset limitation, and the payment protocol. It is largely complete, with only minor operational details missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the single address parameter is already documented structurally. The description adds only that the address is a creator address, which is useful framing but not much 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 verb and resource: given a creator address, return every pair it created, plus first/last seen timestamps and counts. It is clearly distinguishable from the sibling deployer_score, which scores a deployer rather than enumerating created pairs.

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 states a clear use case: spot serial launchers and repeat ruggers. However, it does not explicitly say when to prefer deployer_score, newpairs, or other siblings, so the routing guidance is good but not complete.

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 well: it discloses the 7-day on-chain outcome window, scoring components (liquidity survival/drain detection, quote liquidity, launch cadence), and the pay-per-call x402/MPP payment behavior including the 402 challenge. It does not fully describe response format or operational failure modes, but adds substantial behavioral context.

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 with the core scoring purpose front-loaded, followed by data inputs and payment mechanics. Every sentence adds useful selection or invocation context, with no wasted framing.

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 scoring tool with no output schema, the description explains the score range, the source data, and the main scoring factors. It leaves the exact response shape and edge cases unspecified, but gives enough context 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 schema has 100% description coverage, but the only parameter description is the bare word "required". The description adds that the address represents a creator address on Base, which is useful, but it does not specify address format or validation details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb and resource: scoring a creator address's deployer track record for Base launches on a 0-100 scale. It is clear what the tool computes, though it does not explicitly differentiate itself from the sibling `deployer` tool.

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 implies the tool should be used when you have a creator address and need a deployer risk/track-record score for Base launches. It does not state when to prefer alternatives like `deployer`, nor does it give exclusions or prerequisites beyond needing an address.

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 model ($0.001 USDC on Base via x402/MPP), that a 402 challenge is returned on unpaid calls, that no API key is needed, and that filings are capped at 10. It omits rate limits and behavior on an invalid/ambiguous ticker or CIK.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two compact sentences, front-loaded with what the tool returns and followed by the payment/access mechanics. No filler, no tautology.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema exists, so the description correctly compensates by enumerating returned fields, and the billing mechanics are covered. Slightly incomplete on identifier ambiguity and error outcomes for a tool with zero annotations.

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 real meaning by stating the lookup is by ticker OR CIK, which clarifies how the two optional properties relate. It does not state whether at least one identifier is mandatory, given that required is empty.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource (fetch official SEC profile for a US public company) and enumerates the payload (name, sector, exchanges, 10 recent filings with dates and SEC links). It is clearly distinct from edgar_search's search semantics because it takes a ticker or CIK identifier, but it never names or explicitly contrasts that sibling.

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 'by stock ticker or CIK' phrasing conveys the precondition that you must already know an identifier, which implicitly routes identifier-less queries elsewhere. There are no explicit when-not conditions or named alternatives among the siblings, 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, the description carries the full burden and does well: it discloses official SEC data, no API key, a pay-per-call price, and the 402 challenge behavior on unpaid calls. It stops short of describing result limits, pagination, or query syntax, which leaves some behavioral gaps.

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 three front-loaded sentences with no wasted filler; purpose and return shape come first, then data source, then payment terms. The payment sentence is dense but earns its place because it prevents a failed unpaid call.

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 three-parameter search tool with no annotations and no output schema, the description covers purpose, return fields, auth, and pricing. It is incomplete on parameter semantics and result behavior, which an agent would still need before invoking confidently.

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 nominally 100%, but the schema text for q, to, and from is only 'required' or 'optional' with no real semantics. The description adds nothing about the query string or date-range meaning of these parameters, so 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 names a specific verb (full-text search) and resource (every SEC EDGAR filing), lists covered form types, and clearly distinguishes this from company-specific retrieval such as edgar_company. An agent can tell exactly what this tool does 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?

Usage is implied by the contrast between full-text search and the sibling edgar_company, but the description never explicitly says when to use this versus edgar_company or caselaw_search. There are no exclusions or routing conditions beyond the implicit 'search broadly' framing.

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 well: it discloses that filings are parsed per call and that the tool is pay-per-call at $0.002 USDC on Base, with a 402 challenge on unpaid calls. It does not cover error behavior, rate limits, or exact result-count limits, but the payment and freshness behavior are unusually 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 compact and front-loaded: the first sentence names the tool's purpose and output, and the second adds source and payment behavior. Every clause contributes useful context without padding.

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 simple two-parameter lookup with no output schema and no annotations, the description covers the data source, the returned fields, and the payment model. It leaves some ambiguity around identifier precedence, result limits, and failure cases, but it is largely 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%, so the schema is the primary parameter reference. The description adds useful meaning by saying the investor may be identified by CIK or name and by clarifying that results are top 13F positions, but it does not explain whether one identifier is preferred or required when both are omitted or supplied.

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 resource and verb: latest SEC 13F holdings for an institutional investor by CIK or name. It also names the returned content (top positions with issuer, value, and share count), making the tool readily distinguishable from broader EDGAR or insider 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?

Usage is implied by the 13F/institutional-holdings framing, but the description gives no explicit when-to-use or when-not-to-use guidance. It also does not route the agent to alternatives such as edgar_company or edgar_search when the task is not specifically 13F holdings.

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 discloses that filings are parsed per call, that data is near real time, and critically that calls are pay-per-call at $0.002 USDC on Base via x402/MPP with a 402 challenge on unpaid calls. It does not describe default result size, ordering, or pagination behavior, which keeps it from a 5.

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 two compact sentences with zero waste. It front-loads the resource and scope, then adds the essential payment/authentication detail, so every sentence 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 simple read tool with one optional parameter and no output schema, the description covers source, freshness, returned fields, and payment mechanics. It leaves minor gaps around limit semantics and result ordering, but an agent has enough to call 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?

There is only one optional parameter, and schema description coverage is nominally 100%, so the baseline is 3. However, the schema's own description for `limit` is merely "optional," and the tool description adds no meaning about its default value, maximum, or effect on results.

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 resource and scope: latest insider trades at US public companies from SEC Form 4, with the exact fields returned (who, company, shares, price). This clearly distinguishes it from sibling SEC tools like edgar_company and edgar_search, which cover filings generally rather than insider transactions.

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 implies usage by defining the resource as near-real-time insider trades, but it gives no explicit when-to-use guidance, no exclusions, and no comparison to alternatives such as edgar_company or edgar_search. An agent can infer the use case but must decide on its own when this is the right 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?

No annotations, so the description carries the full burden, and it does substantial work: it discloses the pay-per-call cost ($0.001 USDC on Base), the payment protocol (x402/MPP), and the concrete behavior that a 402 challenge is returned on unpaid calls. It also describes the return shape (titles, years, links). Pagination and rate limits are not mentioned, which keeps it below 5.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, zero waste, and the core purpose and source are front-loaded. The payment caveat follows as a compact operational note rather than bloating the opening.

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 single-parameter search tool with no output schema, the description covers purpose, source, return fields, and the non-obvious payment requirement that an agent would otherwise stumble into via a 402 response. Nothing needed to invoke it correctly 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?

Only one parameter with 100% schema coverage, so the schema already satisfies the documentation need. The description's phrase 'matching a query' adds only marginal meaning that q is a free-text search string, with no syntax or format guidance.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Search UK legislation'), names the authoritative source, and enumerates the covered material (Acts and statutory instruments). This clearly distinguishes it from the caselaw_* siblings, which cover a different body of law.

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 establishes context clearly: this is for UK statute (legislation.gov.uk, the official revised statute book), which implicitly routes agents away from caselaw_search. It stops short of explicitly naming an alternative or stating when-not to use it, so no explicit 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 burden, and it does disclose the notable commercial behavior: $0.001 per call in USDC on Base via x402/MPP, with a 402 challenge on unpaid calls — genuinely useful context an agent cannot get elsewhere. It stays silent on redirect handling, JS-rendered pages, page-size limits, and failure modes, which matters for a network-fetch tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, zero waste: the capability first, then the payment constraint. Front-loaded and 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?

No output schema exists, so the description correctly specifies the return shape (absolute URL plus anchor text) and the payment flow. What remains thin is operational edge-case behavior for fetching arbitrary pages, but nothing essential to selecting or invoking the tool is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with a single required 'url' parameter, so the baseline is 3. The description adds only that the URL is a 'web page'; it gives no hint about scheme requirements, redirect targets, or whether non-HTML resources are rejected.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Fetch a web page') plus the exact shape of what comes back ('all unique links ... absolute URL plus anchor text'). That output emphasis implicitly separates it from sibling 'reader', but it never names or contrasts with that sibling explicitly.

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 statement of when to reach for this over 'reader' or any other fetch-type sibling, and no prerequisites or exclusions. Usage is only inferable from the 'return all unique links' phrasing.

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 discloses the pay-per-call cost ($0.001 USDC on Base) and, critically, that unpaid calls return a 402 challenge via x402/MPP. That is exactly the kind of context an agent needs to avoid spurious retries. It omits failure modes (non-HTML targets, timeouts, redirects) and payload-size limits, keeping it below 5.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the core purpose and return payload, then the billing caveat. Zero filler and 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 one-parameter tool with no output schema and no annotations, the description effectively substitutes for a return schema by enumerating the metadata fields, and it covers the payment/auth flow. Missing only edge-case behavior (error responses other than 402, non-HTML pages), which is 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?

There is a single required `url` parameter with 100% schema coverage, which sets the baseline at 3. The description adds no semantics beyond that (no notes on absolute vs relative URLs, redirects, or whether the fetched resource must be HTML), so it neither helps nor hurts.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource (fetch a web page) and enumerates the exact metadata categories returned: title, description, Open Graph, Twitter cards, canonical, JSON-LD. That is concrete and lets an agent know precisely what comes back. It is docked one point because it does not distinguish itself from the sibling `reader` tool, which likely also fetches page content.

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 output description: use this when you want structured page metadata rather than raw content. However, there is no explicit guidance on when to choose this over the `reader` sibling, and no stated exclusions or prerequisites.

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 model ($0.001 USDC on Base), the x402/MPP mechanism including that unpaid calls return a 402 challenge, and that data is continuously collected on-chain. It stops short of stating rate limits, freshness lag, or whether results are paginated.

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 front-loaded sentences: what it is, how data is sourced, how it is paid for. The payment sentence is long but operationally necessary since a 402 will otherwise look like a failure. 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?

There is no output schema, and the description recovers this partly by naming the returned tagging fields. However, for a zero-required-param query tool, it omits what a default call returns (time window, row cap) and never explains hours/limit, leaving the agent unable to control result size.

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%, but both properties are described only as 'optional', so the schema conveys almost no meaning either. The description never mentions hours or limit, so an agent gets no guidance on defaults, accepted formats for these string-typed params, or how they bound the result 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?

States a specific resource (new liquidity pairs on Base, UniswapV2-style) and what enriches each record (creator address plus EOA/contract tag). It is clear what the tool returns, though 'new' is never bounded (time window, since-last-call), which leaves the core selection criterion 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?

Usage is only implied by the noun phrase 'new liquidity pairs'; there is no explicit when-to-use, no prerequisites, and no pointer to alternatives such as deployer or deployer_score, which look like the closest functional neighbours for creator analysis.

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 the two behaviors an agent most needs: pay-per-call pricing ($0.002 USDC on Base, x402/MPP) and that unpaid calls return a 402 challenge. It stops short of error modes, timeouts, or whether extraction fails gracefully on non-article content.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, both load-bearing: the first states the operation and output shape, the second states cost and payment mechanics. Front-loaded and zero filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

There is no output schema, and the description compensates by stating the return is 'main article content as clean text', which is exactly what an agent needs to chain the output. Payment behavior is also covered. Only failure/timeout semantics are missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% (the single 'url' param is required), so the schema already covers the input; the baseline would be 3-4. The description adds meaning by qualifying the URL as a 'web page' whose 'main article content' is extracted, implying article-style HTML targets rather than arbitrary URLs. It does not go further into format constraints.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Fetch a web page') plus the transformation performed ('return its main article content as clean text'), with the parenthetical 'reader extraction' reinforcing the mode. No sibling in the list does web-page extraction, so it 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?

Implied usage is clear from the name and description (use when you need readable text from a URL rather than raw HTML), but it never says when to prefer this over alternatives or what happens with non-article pages, PDFs, or blocked sites. Guidance is inferable rather than stated.

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 on two counts: it discloses the return shape (feed title plus items with title, link, date, summary) and the payment model ($0.001 per call, USDC on Base, 402 challenge returned on unpaid calls). It omits failure behavior for invalid/non-feed URLs and any redirect or timeout handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, both front-loaded: what it does and what it returns comes first, with the pricing/402 caveat attached after. No filler or restated title.

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 a single required parameter, no output schema, and no annotations, the description covers purpose, return fields, and cost/auth mechanics – enough for an agent to call it correctly. The remaining gap is error and edge-case behavior for non-feed URLs.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

One parameter with nominally 100% schema coverage, but the schema text is only the redundant word 'required', so the description contributes the real meaning: the input must be an RSS or Atom feed URL. It does not state whether the URL must be absolute, http(s)-only, or whether redirects are followed, so it adds only modest value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: fetch an RSS or Atom feed URL, parsed to JSON. That implicitly separates it from siblings like `reader` (general fetching) and the caselaw/edgar search tools, though it never names or contrasts any sibling explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied by the resource type – an agent can infer it should be called when a syndication feed must be parsed. There is no statement of when not to use it, no contrast with `reader` for non-feed URLs, and no mention of what happens with HTML or malformed URLs.

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 coverage (OFAC SDN + OFSI), refresh cadence ('refreshed daily from official government sources'), return contents (list, program/regime, match score), and crucially the payment behavior and 402 challenge on unpaid calls. It stops short of explaining match-score semantics or rate/usage limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with purpose and data sources, then output shape, then operational/payment facts; no filler. Slightly dense with x402/MPP jargon, but each sentence earns its place for an agent that must know about the 402 payment challenge.

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 single-parameter tool with no output schema and no annotations, the description covers sources, freshness, return fields, and the pay-per-call/402 behavior — enough to call it and anticipate a challenge. The main residual gap is match-score interpretation and any request-format expectations.

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% but the only schema description is the bare 'required', so the description's clarification that the name can be a person or company is genuinely additive. However, it does not specify formatting (individual vs entity, aliases, transliteration), so the schema still leaves most input semantics unaddressed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Sanctions screening: check a person or company name') plus the exact data sources (OFAC SDN, UK OFSI list), which no sibling tool covers. An agent can distinguish this from caselaw/EDGAR/legislation search tools at a glance.

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 'check a person or company name' framing implies entity-screening usage, but there is no explicit when-to-use or when-not-to-use guidance, nor any stated prerequisites such as needing a legal/entity name or how to interpret low vs high match scores. With no sibling screening tools, alternatives are moot, but the guidance is only 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 burden and does well: it discloses the 0.3% integrator fee on executed swaps, the 60+ chain coverage, and the $0.002 pay-per-call model with a 402 challenge on unpaid calls. It stops short of stating the critical behavior that this tool only returns calldata and does not broadcast the swap, which for a financial mutation-adjacent tool is a notable omission.

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 densely packed sentences, front-loaded with purpose before fees, chains, and pricing. Every sentence carries distinct information, though the pricing/auth sentence is compressed enough that the fee and payment mechanics take a second read.

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 7-parameter tool with no annotations and no output schema, the description covers cost, chain coverage, fee, and the rough return shape ('ready-to-sign transaction data'). It leaves gaps an agent needs to call correctly: response fields (amounts, route, gas, tx object), slippage default, and whether the returned calldata must be signed externally.

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%, but every schema description is just 'required'/'optional', so the only added semantics come from the description's mention of Base plus 60 chains and cross-chain routing via LI.FI, which hints at how fromChain/toChain are used. Slippage format/default, amount units (raw vs decimal), and token identifier format (symbol vs address) remain unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('swap quotes with executable calldata') plus the mechanism (races LI.FI, KyberSwap, Velora) and output ('best net output with ready-to-sign transaction data'). No sibling tool in the list is a swap router, so the scope is unambiguous on its own.

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 'swap quotes ... ready-to-sign transaction data' and by the note that cross-chain goes via LI.FI, but there is no explicit when-to-use/when-not statement, no prerequisite list (e.g. funded wallet, approval state), and no guidance on what to do when no route is found.

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