Greynoise

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

The description adds significant behavioral context beyond the annotations: it explains the default model (free), the need for an API key to access Anthropic (with cost implication), and the return structure (per-model score, confidence, signals, raw_response, plus combined view). This fully aligns with the annotations (readOnly, idempotent, openWorld, not destructive) and provides extra transparency.

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

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

The description is a single paragraph that efficiently conveys purpose, usage, parameters, and returns. It is front-loaded with the main action. While it could be slightly more structured (e.g., bullet points), it is concise and each sentence adds value.

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 purpose, parameters, return format, and use cases. Since there is no output schema, the description appropriately includes the return structure. It is complete for the tool's complexity, though it could mention error handling or rate limits if applicable.

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% description coverage, so the baseline is 3. The description adds extra value by clarifying the default model, explaining when `_apiKey` is needed, and providing examples for the `entity` parameter. This goes beyond the schema 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 states the tool probes LLMs for knowledge about an entity and scores visibility 0-100. It specifies the action (probe, score) and resource (LLMs), and differentiates by mentioning specific use cases like AI-marketing audits, brand checks, and competitive monitoring, which are distinct from 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?

The description provides clear contexts for use: AI-marketing audits, pre-launch brand checks, competitive monitoring. It also explains when to provide the Anthropic API key. However, it does not explicitly state when not to use the tool or mention alternatives among the 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?

Annotations already cover read-only, open-world, idempotent, and non-destructive behavior, so the bar for added behavioral context is met by the description. It adds useful behavior beyond annotations: the tool 'fills arguments,' returns 'the structured answer with stable pipeworx:// citation URIs,' and 'works on every tier, one fast call.' It does not contradict 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 long but well-structured and front-loaded: it starts with the critical preference directive, then scope, then usage triggers, examples, and escalation paths. Every section earns its place, and the examples are concrete enough to disambiguate the intended input format without being redundant.

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 broad, general-purpose question-answering tool with no output schema, the description is remarkably complete. It explains what the tool does, when to use it, what it returns (structured answer with citation URIs), how it relates to siblings, and what kinds of questions are appropriate. No critical operational gap remains for an agent deciding whether and how to call it.

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 all six parameters documented as aliases for the same natural-language 'question' input. The description reinforces that the tool accepts questions and provides examples, but it does not need to add much semantic detail because the schema already fully describes the single meaningful parameter.

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 router/aggregator tool: it routes questions to one of 5,706 tools across 1,493 sources and returns structured answers. It explicitly distinguishes itself from siblings by naming ask_pipeworx_grounded and deep_research as escalation paths, and positions ask_pipeworx as the default entry point.

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 when-to-use guidance: 'PREFER OVER WEB SEARCH', 'Use whenever the user asks...', and includes concrete example questions. It also states when NOT to use it and which alternatives to step up to, such as ask_pipeworx_grounded for hallucination-resistant single answers and deep_research for broad multi-part questions.

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?

Beyond the annotations, the description discloses that it is an experimental variant with candidate routing improvements toggled live, that no candidate is currently active, and that it does not fall back to another tool. This adds meaningful behavior context without contradicting the 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?

Four sentences carry specific useful details: beta status, current equivalence, usage guidance, and no-fallback guarantee. Slightly dense with extraneous specifics like the retirement date, but no wasted sentences.

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

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

Given the large surface area and no output schema, the description supplies enough context by referencing ask_pipeworx's response shape and stating this is a working router. It could be more explicit about what 'routing' means for the answer, but for a variant tool it is reasonably 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?

Input schema documentation covers all six parameters at 100%, so the description correctly defers to it. It only says 'same arguments' rather than adding new semantics, which is acceptable when schema coverage is complete.

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 tool as a beta version of ask_pipeworx and a universal router with the same 5,706 tools, arguments, and response shape. It also states it is a full working router rather than a fallback, which distinguishes it from the stable sibling and clarifies its purpose.

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 says to use it exactly like ask_pipeworx when you want the newest routing and notes the current state matches the stable version. It doesn't explicitly exclude other use cases or mention grounded alternatives, but the conditional guidance is clear enough.

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?

Annotations already mark read-only, open-world, and idempotent, but the description adds substantial non-obvious context: it routes across 5,706 tools and 1,493 sources, fills arguments, fetches data, and extracts answers ONLY from the tool result. It also discloses the refusal contract with enumerated refusal_reason values and the cost of one extra LLM call, all beyond annotation coverage. No contradiction.

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?

Four sentences, each carrying distinct value: definition, mechanism and output contract, refusal modes, and usage/cost trade-off. No filler or redundant restatement; the most important differentiator is 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?

With no output schema, the description fully documents the success return object {answer, evidence, confidence, source, fetched_at, refusal_reason:null} and the failure refusal structure with reason enum. It covers required input, when to use, and cost trade-off. An agent lacks nothing needed to select and 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?

Schema coverage is 100%, so the baseline of 3 applies. All six parameters are aliases for the same question string and are fully described in the schema, so the tool description adds no new parameter-level meaning—which is acceptable but does not earn credit beyond 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 'Hallucination-resistant answer mode for high-stakes reads,' naming both the mode and its intended severity. It distinguishes itself from sibling ask_pipeworx by describing the same routing but stricter extraction-only-from-tool-result behavior plus explicit refusal outputs.

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?

Explicitly says when to use: for answers that will be quoted, cited, or acted on when the agent must not invent facts, listing concrete domains (financial verdicts, legal claims, medical lookups, public statements). Also gives the exclusion: prefer ask_pipeworx for casual lookups due to the extra LLM call cost.

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?

The description extensively details behavioral traits: low-confidence resolution short-circuits, closed/dead market handling, wide-spread market flags, resolution-rule risk parsing, and fan-out behavior. These go well beyond annotations (readOnlyHint, idempotentHint) and provide critical transparency for safe 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 description is a single dense paragraph without structural elements like bullet points or sections. While it contains valuable information, it is not concise or easily scannable. Front-loading the main purpose helps, but overall it is verbose.

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?

Despite no output schema, the description thoroughly explains response shapes, resolver contract, parent_event extractor, news fields, and safety features. It covers edge cases and provides all necessary context for an agent to use the tool correctly. No gaps remain.

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 all parameters. The description adds value by elaborating on the 'market' parameter with examples and clarifying the 'depth' and 'include_raw' parameters with usage guidance. This extra context justifies a 4.

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 the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It lists specific use cases ('should I bet on X', 'what does the data say about Y', 'is there edge in Z') and distinguishes from sibling tools by focusing on comprehensive single-bet research with fan-out to multiple data sources.

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 explicit use cases and examples of when to use the tool. It implies when not to use (e.g., for quick edge checks, other tools might be more appropriate) but does not explicitly name alternatives. The guidance is clear and specific, earning a 4.

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?

Annotations already declare readOnlyHint and idempotentHint. The description adds specific behavioral details: pulls from SEC EDGAR/XBRL for companies, FAERS/FDA for drugs, handles fiscal year differences, sorts results, and returns citation URIs. No contradictions.

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 front-loads example queries and then provides structural details. While dense, it is efficient and every sentence adds value. Slight lack of formatting but still effective.

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 complexity (two entity types, multiple data sources, no output schema), the description adequately explains input parameters, data pulled, sorting, and output includes URIs. It does not detail exact output structure but covers what is needed for an agent to select and 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%, but the description adds meaningful context: explains how 'type' determines data sources and provides examples for 'values' (tickers for companies, drug names). This helps the agent understand parameter semantics beyond the schema 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 uses specific trigger phrases like 'compare X and Y', 'which is bigger', and explicitly states it provides side-by-side comparison of 2-5 companies or drugs in one call. It clearly distinguishes from sequential lookups and from sibling tools like entity_profile.

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 advises to 'ALWAYS PREFER over sequential single-pack lookups' when comparing entities, and provides a list of query types that trigger this tool. It implicitly indicates when not to use (if not comparing multiple entities).

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?

Beyond the readOnly/openWorld/idempotent annotations, it discloses account requirements and the paid depth tier, parallel facet decomposition, a findings packet with verbatim evidence/confidence/source/fetched_at/citation, explicit gaps[] and no invention, contradictions[] for deeper depths, hop fields, fetchable citation_uri conditionality, semantic excerpting, and expected latency. This exceeds what annotations alone provide and matches no contradiction.

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 long, but nearly every sentence carries distinct, decision-relevant information and it is front-loaded with the account requirement and the ask_pipeworx fallback. Minor redundancy across the three 'use ask_pipeworx instead' conditions keeps the overall length from being perfectly concise, though the density is justified.

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?

Even without an output schema, the description specifies what the returned findings packet contains and what optional fields mean (contradictions[], gaps[], hop, citation_uri), plus latency and auth constraints. For a 2-parameter tool with this much behavioral nuance, an agent has everything needed to select and 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?

Schema coverage is 100%, but the description adds substantial meaning to the depth parameter by defining quick=3 single-hop, standard=3 with gap recovery plus contradictions, and thorough=6 paid with iterative lead-chasing. It also clarifies that question should be broad/multi-part, reinforcing the schema description with selection-oriented 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 verb+resource: grounded multi-source research across Pipeworx's 1,493 structured data sources in one call, and explicitly says it is NOT open-web search. It also distinguishes itself from ask_pipeworx as the batch/parallel research option. An agent can clearly identify what this tool contributes.

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 when-to-use and when-not-to-use guidance: use ask_pipeworx when not signed in, for single lookups, and for breaking or colloquial current-news topics; use deep_research for broad/multi-part structured-data questions. It even explains the failure mode (empty gaps[]) for out-of-catalog topics, leaving no ambiguity about 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds value by explaining that results are 'ready to call directly' and include full schemas with examples, which is useful behavioral context beyond the 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 front-loaded with the core purpose and packed with specific domain examples, but is slightly verbose. Every sentence adds value, however it could be tightened slightly without losing 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?

Despite having no output schema, the description fully explains what the tool returns (top-N most relevant tools with names, descriptions, full input schemas). Combined with clear usage guidance and parameter semantics, the description is completely informative for an AI agent.

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 each parameter is described, but the description adds value by explaining that multiple aliases (q, task, search, description) all map to the same query parameter and provides concrete example queries.

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 uses a specific verb-noun pair ('Find tools by describing the data or task') and enumerates numerous example domains, distinguishing this from sibling tools which are more specific search or analysis 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?

Explicitly states 'Call this FIRST when you have many tools available and want to see the option set (not just one answer),' providing clear when-to-use guidance and context relative to other 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?

The description discloses behavioral traits beyond annotations, such as the patent data source with a known sunset date ('soft-fails until reactivated'), the use of GDELT→GNews fallback, and the sorting of fundamentals. It also confirms read-only behavior, aligning with annotations but adding context about data freshness and failure modes.

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 efficiently conveys key information, examples, and preferences. While it is not overly long, it could benefit from breaks or bullet points for readability. However, every sentence adds value, so it remains fairly concise.

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?

Without an output schema, the description provides a good overview of the returned data (e.g., 'up to 5' filings, 'LATEST 10-K' fundamentals, fallback behavior). It does not specify the exact output format (e.g., JSON structure), but the examples of pipeworx URIs and patent status are sufficient for an agent to understand the tool's capabilities.

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 the 'type' and 'value' parameters. The description adds practical examples ('AAPL', '0000320193') and reinforces that names are not supported, which adds value beyond the schema's basic 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 explicitly states the tool returns a 'full cross-source profile of a US public company in ONE parallel call' and lists the specific data components (CIK, filings, fundamentals, patents, news, LEI). It distinguishes itself from siblings like 'compare_entities' and 'resolve_entity' by focusing on holistic company profiles.

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 clearly advises to 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also explicitly states that names are not supported and directs users to 'use resolve_entity first if you only have a name,' providing clear when-to-use and when-not-to-use 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?

Annotations already mark destructiveHint true. Description adds context about clearing sensitive data and pairing with other tools, which is consistent and adds value.

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 action. No wasted words.

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?

Simple tool with one required parameter and no output schema. Description covers purpose, usage, and paired tools adequately.

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. Description adds no additional semantics beyond 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?

Clearly states 'Delete a previously stored memory by key', using specific verb and resource. Distinguishes from siblings remember and recall.

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?

Explicitly provides when to use: 'when context is stale, the task is done, or you want to clear sensitive data'. Also pairs with remember and recall as 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?

Annotations declare readOnlyHint, idempotentHint, destructiveHint. The description adds that it fetches the page, extracts title/description/key links, and emits standard markdown. This is useful context beyond annotations, though edge cases like invalid URLs are not 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 three sentences, front-loaded with purpose, and each sentence adds value. No wasted words or repetition. It efficiently conveys what the tool does, how it works, and when to use it.

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, but the description explains output as a 'single text blob ready to drop at site-root/llms.txt'. It covers input parameters, process, and use cases. The missing details on error handling or format spec are minor given the tool's simplicity.

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 both parameters described. The description does not add new meaning beyond implying that max_links limits extracted entries. Baseline 3 is appropriate as the schema already handles 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 clearly states the tool generates a production-ready llms.txt file for any URL, specifying the verb 'generate' and the resource 'llms.txt file'. It differentiates from siblings like scan_competitor_ai_presence by focusing on standard format output.

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 explicit use cases: getting client's site indexed, drafting for own project, auditing competitor. It does not mention when not to use it, but the three use cases give clear guidance. Exclusion of alternatives is not needed given the unique purpose.

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?

Annotations indicate read-only, open-world, idempotent, non-destructive. The description adds value by specifying the data source (GreyNoise Community), authentication requirement (BYO API key), and return fields including a deep link. No contradictions.

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: first states action, second lists return fields. Front-loaded and efficient. No wasted words.

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 classification tool with an output schema, the description covers the key aspects: input, data source, authentication, and output fields. It is sufficiently 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?

Only one parameter 'ip' with schema description 'IPv4 address'. Description does not significantly add beyond schema; baseline score is appropriate given 100% 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 clearly states it classifies an IPv4 address using the GreyNoise Community dataset and lists return fields. It distinguishes from sibling tools which focus on entities, research, or subscriptions.

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 'BYO API key' as a prerequisite but does not explicitly state when to use vs. alternatives. However, the purpose is clear enough that an agent would recognize it for IP reputation classification.

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?

Annotations already declare read-only, idempotent, non-destructive. Description adds return field details and context, building on annotations without contradiction.

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 efficient sentences with no extraneous content; first states function, second provides usage guidance.

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 tool with one optional parameter and annotations covering safety, the description fully explains purpose, output, and use case.

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 clear parameter description. Description does not add additional semantics beyond what the schema provides, so 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?

Clearly states the tool lists active subscriptions and specifies return fields. Distinguishes from sibling tools like subscribe and unsubscribe.

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

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

Provides explicit usage guidance: review before subscribing or to get a cancellation ID. Does not explicitly state when not to use, but context is 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 all annotations false, the description carries the full burden of behavioral disclosure, and it exceeds it. It explains the claim_token mechanism ('Filing without an account returns a claim_token; pass it back later... to read whether it was fixed and what changed'), rate limits ('Rate-limited to 5 per identifier per day'), quota exemption, and the instruction to not paste end-user prompts. No contradiction with 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 front-loaded with a clear purpose, then flows logically through usage criteria, exclusions, message formatting, claim_token mechanics, and operational details (rate limit, quota, daily digests). Every sentence introduces new, relevant information without repetition or filler, so the length is justified and well-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?

Given the tool's complexity—4 params, nested context object, no output schema, and all-false annotations—the description is remarkably complete. It covers all feedback categories, provides the claim_token follow-up workflow, specifies rate limits, clarifies quota impact, and defines the scope of valid reports. An agent could invoke this tool confidently for both initial filing and subsequent status checks.

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?

Even though the schema covers all 4 parameters, the description adds meaningful usage semantics beyond the field names: it gives a concrete invocation pattern for claim_token ('pass the pwfb_… token that filing returned, with no other arguments'), constrains message content ('describe in terms of Pipeworx tools/packs — don't paste the end-user's prompt'), and explains the optional context object's purpose. This is substantial value 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 opens with a clear, specific action: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It names the resource (Pipeworx team) and distinguishes itself from siblings like ask_pipeworx by focusing on reporting rather than querying. The purpose is unmistakable and tightly scoped.

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 explicit when-to-use criteria: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also gives a direct exclusion for tools from other MCP servers: 'ONLY for tools served by this Pipeworx connection – if the tool came from a different MCP server... file it with that server instead.' This is textbook usage guidance with clear 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?

Annotations already indicate read-only, open-world, and idempotent properties. The description adds caching behavior (5min-1h), data source (CF analytics-engine), and privacy (no PII), providing valuable context beyond 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?

Three sentences, efficiently structured with bullet-like list for use cases. Every sentence adds value; no wasted words.

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 tool with one parameter and no output schema, the description covers purpose, usage, data source, caching, and privacy. The return is described generically but adequately. Minor improvement could be exact output structure.

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 enum parameter. The schema already explains the window options well. The description adds slightly more context about when to use each window, justifying 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 states the tool returns top tools, packs, and call volume over a window. It distinguishes itself from sibling tools by focusing on aggregated trending data, not individual queries or entity profiles.

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?

Three explicit use cases are given: discovering hot data sources, confirming canonical tools, and aligning use case with agent needs. It lacks explicit when-not-to-use directions but the context is clear and helpful for 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?

Annotations declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false. The description adds significant behavioral details: semantic anchor with Jaccard similarity, partition filter for placeholder slugs, fill check against live CLOB depth, and a warning not to trade when realizable_edge_pp ≤ 0. No contradictions with 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 thorough and front-loaded with the core purpose. However, it is somewhat verbose with many technical details (e.g., Jaccard threshold, placeholder fraction). It could be slightly more concise while retaining 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 provides a summary of the response structure for both modes, including fields like gap_pp, suggested_trade, reasoning, and partition_check details. It also mentions fill check behavior. Without an output schema, this is fairly complete, though it could describe error conditions or edge cases more thoroughly.

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 covers 100% of parameters with descriptions. The description adds substantial meaning: it explains the modes corresponding to each parameter, provides example values, and clarifies that no args triggers trending_scan. This goes well 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 clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It explains two distinct modes (event and topic) with specific use cases, providing a clear verb-resource pair.

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 says when to call with no arguments (trending_scan), when to use event (specific market), and when to use topic (cross-event scanning). It recommends event for specific markets and suggests an alternative tool (polymarket_fill_risk) for custom sizing, providing clear 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds extensive behavioral context: model families (crypto_price, news_momentum, partition_overround, concentrated_longshot), edge calculation details, slippage assumptions, caching (1h at KV level), and diagnostic fields. No contradiction with 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 very dense and technical, covering model formulas and caching details. It is well-structured with sections (by_segment, tradeable-edge knobs, response top-level) and front-loaded with the core purpose. However, it could be more concise for an AI agent.

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 (9 parameters, no output schema, nested response structure), the description is extremely complete. It explains the response format (by_segment, fed_candidates, diagnostics), tradeable-edge knobs, and caching. Without an output schema, the description fully compensates by detailing return values.

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 description enriches every parameter with usage context. For example, slippage_pp explains Polymarket's fee structure, min_liquidity explains the rationale for filtering, and category_filter lists valid values. This goes 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 states the tool scans Polymarket markets and returns opportunities where Pipeworx data disagrees with market price. It uses specific verbs ('Scan top Polymarket markets and return opportunities') and identifies the resource (Polymarket markets). The detailed explanation of the three segments distinguishes it from sibling tools like polymarket_arbitrage or polymarket_edge_tracker.

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 frames the tool for 'what should I bet on today' and explains the three segments with their purposes. It advises that Fed bets are excluded from ranking due to unreliable signal and mentions caching. However, it does not explicitly state when not to use this tool or how it compares to sibling tools like polymarket_arbitrage.

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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive. Description adds behavioral nuances: snapshot TTL (60-day), decay from daily closes (not intraday), gaps meaning no scan that day. No contradictions with 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?

Description is lengthy with technical details but structured clearly with sections (args, RESPONSE, LIMITS). However, it could be more concise; some sentences are dense and require careful parsing.

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, but description thoroughly explains the return fields (tracked[], expired[], snapshot_dates[]) with key attributes and semantics, making the tool's response predictable.

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 covers 100% of parameters with descriptions. Description only reiterates defaults and max days without adding new 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?

Description clearly states the tool provides 'edge persistence and decay telemetry' and answers a specific question about edge age and shrinkage. It distinguishes itself from sibling polymarket_edges by focusing on temporal analysis rather than current edges.

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?

Implies usage for judging trade quality based on edge persistence (fresh vs. old wide edge) but lacks explicit when-to-use or when-not-to-use instructions. No direct mention of alternatives like polymarket_edges for current snapshots.

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?

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds behavioral context: 'walks the ladder', returns specific fields like slippage_pp, verdict, thin_legs, and warns about 'forced_directional_risk'. Since annotations cover the basics (read-only, non-destructive, state-dependent), the description provides supplementary detail without contradiction.

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 core purpose and uses capitalized section headers (REQUIRES, SINGLE-MARKET, BASKET) to organize. However, it is verbose with run-on sentences (e.g., the last sentence) and could be tightened. Some details like parameter defaults could be left to schema, but overall structure is clear.

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?

Despite no output schema, the description lists all return fields for both single-market (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict) and basket (theoretical_sum, realizable_sum, capture_ratio, profit_usd, per-leg fill detail, thin_legs, max_clean_notional_usd, forced_directional_risk). It also explains risks and provides usage thresholds. This is highly complete for agent decision-making.

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 descriptions for all four parameters. The description adds meaning by explaining modes: market for single-market, event for basket, and how side defaults to 'auto' based on partition sum for basket. It interprets size_usd differently for single-market (max spend/target proceeds) vs basket (settlement notional). This goes beyond schema to clarify parameter behavior in context.

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 the tool performs a 'realizable-vs-theoretical edge check against live CLOB order-book depth' with specific modes (single-market vs basket) and parameters (market/event, side, size_usd). It distinguishes itself from siblings by advising use before acting on signals from polymarket_arbitrage or polymarket_edges. The verb 'check' combined with the resource 'fill risk' is specific and 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 states 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It explains the rationale: theoretical overround on thin books is not capturable and partial basket fills convert an arb into an unhedged directional position. This provides clear when-to-use and why, with implicit alternatives from 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?

Annotations already mark it read-only and idempotent, and the description adds substantial behavioral detail without contradicting them: it discloses compatibility_warning and compatibility_codes, that unknown legs are never paired, that skipped counters exist, and that unmatched pairs land in low_confidence_pairs for inspection only. This is far beyond what the annotations alone convey and there is no contradiction.

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 long but densely organized: purpose, modes, response shape, safety fields, and caveats are each labeled in a readable flow. Every major clause contributes needed operational detail, especially since there is no output schema. It is slightly longer than strictly necessary, but the structure earns 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 there is no output schema, the description compensates by documenting response contents: venue legs, matched spreads with top_spreads_pp, compatibility codes, temporal alignment, skipped cross-type/cross-subtype counters, and low_confidence_pairs. It also explains the realistic caveat that most pre-mapped topics are not currently tradeable. An agent has enough information to call the tool and interpret results 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 100% of parameters with descriptions, including the topic values and the fact that kalshi_event_ticker and polymarket_event_slug override the topic-mapped side. The tool description reinforces this by explaining the two modes and giving example formats, but it does not add meaningful parameter semantics beyond what the schema already provides, 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 opens with a specific verb and resource: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It goes beyond a generic label by explaining the comparison basis (same outcome, same resolving question) and how the spread is computed (Kalshi − Polymarket), making it clearly distinguishable from same-venue or single-venue 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 two modes (topic shortcuts vs explicit ticker/slug) are explicitly described, including how explicit parameters override the topic-mapped side. A clear caution is given that most pre-mapped topics currently return compatibility warnings and that 'pre-mapped ≠ tradeable,' which prevents misuse. It does not name alternative tools or explicitly say when to prefer a sibling, 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?

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds context beyond annotations, such as scoping to an identifier and listing behavior when 'key' is omitted. No contradictions.

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 sentences, front-loaded with the core function. Every sentence adds value, and there is no unnecessary 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 simple retrieval tool with no output schema, the description covers purpose, usage, scoping, and interaction with sibling tools. It is thorough and leaves no major gaps.

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 optional 'key' parameter described. The description reinforces the schema ('omitting key lists all keys') and adds examples of potential key values, but does not significantly add new 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 clearly states that 'recall' retrieves a value saved via 'remember' or lists all keys if 'key' is omitted. It provides concrete examples of what can be stored (target ticker, address, research notes) and distinguishes itself from sibling tools 'remember' and 'forget' by describing their relationship.

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 when to use the tool: to look up previously stored context without re-deriving it. It also mentions scoping to an identifier and pairing with 'remember' and 'forget'. While it doesn't explicitly state when not to use it, the guidance is clear enough for a simple retrieval 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?

The description mentions that mark_read:true flags events as read, which implies a state modification. The annotations declare readOnlyHint=true, creating a contradiction. The description's transparency is undermined by this inconsistency.

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 sentences long, front-loaded with the purpose, and covers all key aspects without extraneous words. Every sentence adds value.

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?

Despite no output schema, the description details return fields and optional behaviors (filtering, mark_read). It also notes polling suitability and an alternative access method, making it complete for an agent.

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 value by providing an example for type ('sec_8k'), clarifying since as ISO timestamp, and explaining the effect of mark_read. This goes beyond the schema 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 states it retrieves recent alerts from the subscription feed, specifying the returned fields (source, citation_uri, payload). It distinguishes itself from siblings like list_subscriptions by focusing on events rather than subscriptions.

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 says 'Polls work fine' and provides an alternative URL for scripts/dashboards, giving context for usage. However, it does not explicitly state when not to use this tool or compare it to siblings.

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?

Annotations already declare readOnly, idempotent, openWorld. The description adds significant behavioral context: parallel fan-out to SEC EDGAR, GDELT/GNews fallback, USPTO soft-fail, and return structure (changes grouped by source, total_changes, citation URIs).

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?

Description is well-structured with front-loaded examples and clear sections. It is slightly verbose but every sentence adds value, neither overly terse nor rambling.

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 complexity (multiple data sources, fallback, soft-fail) and no output schema, the description covers all necessary aspects: input formats, behavior, output structure, and alternative tools. No gaps remain.

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%, meeting baseline of 3. Description adds value with detailed explanation of `since` format including examples and recommended values, and clarifies `type` is limited to 'company'. This guidance surpasses schema 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 states the tool fetches recent changes (filings, news, patents) for a company within a time window. It differentiates from sibling entity_profile by specifying that tool provides static profiles regardless of time window.

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 example queries like 'What's new with X' and explicitly advises use of entity_profile for static profiles, providing clear when-to-use and when-not-to-use 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?

The description adds value beyond annotations: it explains scoping ('by your identifier'), authentication-dependent persistence ('Authenticated users get persistent memory; anonymous sessions retain memory for 24 hours'), and the nature of storage (key-value pair). Annotations already indicate idempotentHint=true and destructiveHint=false, and the description aligns with those.

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 concise (5 sentences) and front-loaded with the core purpose. Every sentence adds value: purpose, usage criterion, storage details, persistence info, and pairing with siblings. No fluff.

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 simplicity (two simple parameters, no output schema), the description is complete. It covers purpose, when to use, parameter semantics (though schema covers them), behavioral nuances (scoping, persistence), and relationships to sibling tools.

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 covers both parameters with descriptions, so baseline is 3. The tool description does not add significant new parameter semantics beyond examples in parentheses. The schema descriptions are already clear, so no deduction or bonus.

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 the tool's purpose: 'Save data the agent will need to reuse later.' It specifies the action (save), the resource (data), and the scope (across conversations/sessions). It also distinguishes from sibling tools like 'recall' and 'forget' by mentioning 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 description provides explicit usage guidance: 'Use when you discover something worth carrying forward.' It also tells when not to use other tools by suggesting alternatives: 'Pair with recall to retrieve later, forget to delete.' Additionally, it explains persistence behavior for authenticated vs. anonymous users.

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?

Annotations already mark the tool as read-only, idempotent, non-destructive. The description adds valuable behavioral details: internal cascading through multiple endpoints, graceful degradation when GLEIF/OpenFIGI unavailable, labeling of unresolved identifiers, and that one call replaces 2-3 manual lookups. No contradiction with 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 longer than average but front-loaded with example queries. Every sentence provides useful information (e.g., supported types, identifier sources, graceful degradation). Could be slightly trimmed without losing value, but overall efficient and well-organized.

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 (two entity types with multiple identifier sources, no output schema), the description is remarkably complete. It covers what is returned (identifiers with source labels, unresolved list), edge cases (degradation, ISIN-to-LEI mapping), and the tool's role among many sibling tools. No critical gaps.

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 descriptions for both parameters (type, value). The description goes far beyond: explains accepted input formats (ticker, CIK, name, ISIN for company; brand/generic for drug), details how ISIN resolves to LEI, and mentions behavior for unresolved identifiers. Adds substantial meaning beyond the schema's enum and text fields.

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 the tool resolves names to canonical identifiers, provides example queries ("What's the ticker for…"), and distinguishes it from sibling tools like entity_profile or compare_entities by directing to use it 'FIRST whenever you have a name but need an ID.'

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?

Explicitly says 'Use FIRST whenever you have a name but need an ID.' Provides concrete example queries and lists supported types (company, drug) with input formats, making it obvious when to invoke this tool over 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint as false. The description adds valuable behavioral context: it probes each entity, ranks by score, and surfaces which is most/least recognized. It also describes the return format (score, confidence, signal density). No contradictions.

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 four sentences long, each providing essential information. It is front-loaded with the main purpose and uses clear, direct language with no wasted words.

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 compensates by explaining the return format (ranked list, score, confidence, signal density). It also ties to sibling ai_visibility_check, gives input semantics, and provides a concrete example. The tool feels complete for its intended use.

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 all parameters. The description adds extra meaning for the entities parameter, specifying that the first entry is treated as the 'subject' for narrative. This goes beyond the basic schema 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 states the verb 'compare' and the resource 'AI visibility across multiple entities', with a concrete example. It distinguishes itself from sibling tools like ai_visibility_check by explicitly noting it aggregates multiple probes and provides a ranked comparison.

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 use case ('competitive AI-marketing audits') and an example question. However, it does not explicitly say when not to use this tool or mention alternatives like compare_entities or ai_visibility_check.

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?

The description goes beyond annotations by detailing partial failure modes ('bundlephobia's first measurement on a new version can take 5-30s; sources_failed will list it if it times out') and the output structure (summary block, per-advisory detail, links). It aligns with the readOnlyHint, idempotentHint, and destructiveHint annotations without contradiction.

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 concise at roughly 5 sentences, with the main purpose front-loaded. Every sentence provides essential information, and the structure is clear and easy 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?

Despite lacking an output schema, the description fully compensates by enumerating the return fields and explaining partial failure behavior. It covers all necessary context for an agent to understand the tool's capabilities and limitations.

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 clear parameter descriptions. The description adds value by noting that scoped packages are accepted for 'package' and that 'version' defaults to latest. This extra context justifies a score above the baseline 3.

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 states it's a composite check for evaluating npm packages, covering safety, size, and licensing. It specifies the verb ('scan'), resource ('dependency'), and scope ('npm'), clearly distinguishing it from sibling tools which are unrelated to package scanning.

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 explicit usage conditions: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me".' It also clarifies limitations ('NPM ecosystem only in v1') and points to alternatives for other ecosystems ('PyPI / Maven / Cargo / Go fall under deps.dev:version directly'), giving comprehensive 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?

Annotations indicate read-only, idempotent, and non-destructive behavior. The description adds technical details: BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K char limit with truncation flag, and that results include character offsets and similarity scores. This is valuable beyond annotations, though a perfect score would require more on idempotency guarantee.

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 moderately long but each sentence is purposeful: purpose, use case, technical details, pairing. It is front-loaded with the primary action. Minor redundancy (e.g., 'P pairs with' could be more concise), but overall efficient.

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, but the description explains returns: top-N passages with character offsets and similarity scores. Covers input limits, embedding details, window size, truncation behavior, and pairing with another tool. Fully addresses what an agent needs to know to use and interpret results.

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 three parameters have schema descriptions (100% coverage). The description enriches with examples for query ('supply-chain risk', etc.), default behavior for limit (1-20, default 5), and context for text (max ~200K chars). This goes beyond the schema but doesn't add critical missing info.

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 'Semantic search INSIDE a fetched record', using a specific verb (search) and resource (record). It distinguishes from siblings by specifying it works inside a fetched document, contrasting with 'ask_pipeworx_grounded' which is mentioned as a paired tool for grounding over passages.

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?

Explicitly advises using when the record is too big for the prompt, emphasizing context savings. Mentions pairing with 'ask_pipeworx_grounded' for grounded reasoning, providing clear when-to-use and 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?

The description adds behavioral context beyond annotations: returns new subscription ID, requires OAuth, details delivery channels with constraints (SMS cap, webhook auto-disable). It aligns with annotations (idempotent, non-destructive) without contradiction.

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 concise, well-structured with clear front-loading of purpose. Each sentence adds necessary details without redundancy, using bullet-like formatting for readability.

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

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

Given no output schema, the description adequately covers return value ('returns the new subscription id'), input parameters, delivery options, and constraints. Could mention how to use the returned ID later (e.g., for unsubscribe), but overall 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%, but the description enhances understanding with concrete examples and constraints (e.g., phone verification, 10/day SMS cap, webhook signing). This adds value beyond the schema 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 clearly states the tool's purpose: 'Create a proactive monitoring subscription to a live-data event stream' with specific verb-resource combination. It distinguishes from siblings like list_subscriptions, unsubscribe, and recent_alerts.

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 specifies when to use (proactive monitoring), includes prerequisites ('Requires a Pipeworx OAuth account'), and provides examples of supported types. It implies when not to use (anonymous accounts) but doesn't explicitly name alternatives like list_subscriptions for managing existing subscriptions.

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?

The description adds valuable behavioral context beyond the annotations: it returns example questions with exact tool usage, drawn from the live catalog. Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint as false, and the description aligns with these.

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 long but well-structured and front-loaded with example queries. Each sentence provides useful information, though it could be slightly more concise without losing detail.

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 single optional parameter and no output schema, the description fully explains what the tool returns and when to use it. It covers all necessary context for an onboarding tool.

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 (topic) with 100% schema coverage. The description adds nuance by listing example topics and clarifying that omitting the argument gives a cross-category spread, adding 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 clearly states the tool's purpose: it returns category-bucketed example questions with the exact tool and argument shapes. It explicitly distinguishes itself as the onboarding entry point for an agent that just connected, differentiating from sibling tools like ask_pipeworx.

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 explicit guidance: 'Use this FIRST when you do not yet know what Pipeworx can do for you.' It also explains when to call with no arguments versus passing a topic, and how it helps learn meta-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?

Discloses ownership enforcement and deactivation behavior, adding significant context beyond annotations. Annotations already indicate idempotent and non-destructive; description reinforces and explains the non-destructive nature.

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, no redundant information. Every sentence adds value: core action, ownership, side effect. Excellent 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 simple one-parameter tool with no output schema, the description fully covers the operation's purpose, constraints, and post-condition. References to 'recent_alerts' provide integration 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 coverage is 100% and the parameter is well-described in the schema. Description merely references 'by id' without adding additional semantic value or constraints 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?

Description clearly states 'Cancel a subscription by id' with specific verb and resource. It distinguishes from siblings like 'subscribe' and 'recent_alerts' by noting deactivation versus deletion and historical event availability.

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

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

Provides clear context: ownership enforcement (only own subscriptions) and side effect (deactivation, not deletion). Implicitly tells when to use but does not explicitly state alternatives or when not to use.

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?

Annotations already declare readOnly, openWorld, idempotent, and non-destructive, but the description adds substantial details: return verdict values, the critical distinction between could_not_verify (not evidence) and unsupported, verification_error details, and the routing logic. This goes well beyond annotation fields and clarifies non-obvious 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 front-loaded with example phrases, then flows into purpose, pipelines, return values, and error semantics. Every sentence carries valuable information, but it is somewhat verbose due to the detailed verdict explanation and pipeline routing, which is justified given the tool's complexity.

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

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

There is no output schema, so the description must explain return values, which it does thoroughly with verdict list, actual value, citation, and reasoning. It also covers error cases and the performance benefit ('Replaces 4–6 sequential calls'), making it complete for a complex tool with no structured 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?

Input schema covers both parameters with descriptions (100% coverage), but the description adds practical context: tolerance_pct overrides implied wording, is capped at 5 by default, and can be set to 1-2 for strict hallucination detection. This enhances the meaning beyond schema descriptions, though the schema itself is already 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 clearly defines the tool as natural-language claim verification with explicit trigger phrases ('fact check', 'verify the claim that…') and specific scope (factual accuracy). It distinguishes from sibling tools by describing two distinct verification paths (SEC EDGAR for company-financial claims, grounded pipeline for others), which is a unique resource and behavior.

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

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

It explicitly states when to use the tool ('Use whenever the agent needs to check whether something a user said is factually correct') and gives concrete examples of claim types. However, it does not explicitly mention when not to use it or compare to alternatives like ask_pipeworx, so it lacks exclusion guidance.

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